1# Changelog — charka
2
3Transpilador COBOL → Rust. El módulo más grande del ecosistema (Fase D
4del plan macro) — el parser COBOL completo es un esfuerzo multi-mes.
5
6### feat(charka-codegen): emisión de Rust desde el IR
7
8Crate nuevo `crates/modules/charka/charka-codegen` — la etapa final del
9pipeline. `generate(&Ir) -> String` produce un fuente Rust (un
10`main.rs`) que, compilado contra `charka-runtime`, ejecuta la lógica
11del programa COBOL.
12
13- Un `struct Program` con un campo por cada dato elemental — `Num`
14  para los numéricos, `Text` para los alfanuméricos; `Program::new()`
15  los inicializa desde sus cláusulas `VALUE`.
16- Un método `p_<párrafo>(&mut self)` por cada párrafo del PROCEDURE;
17  `run()` los encadena en orden (el «caer» de COBOL); `main()`
18  construye el `Program` y lo corre.
19- Cada `Stmt` → código Rust: `MOVE`→`.store`/`.fill`,
20  `DISPLAY`→`println!`, `COMPUTE` y la aritmética → expresiones
21  `Decimal`, `IF`→`if`/`else`, `PERFORM`→ llamada de método / `for` /
22  `while`, `GO TO`→ llamada + `return`, `STOP RUN`→`process::exit`.
23- Tolerante: lo no transpilable (`Stmt::Unknown`, un dato sin resolver,
24  el operador `**`) se emite como comentario `// charka:`; el código
25  generado siempre compila.
26- Saneado de identificadores COBOL→Rust (incl. choques con keywords).
27- Verificado de punta a punta: un programa COBOL de demostración
28  transpila a Rust que compila contra `charka-runtime` y produce la
29  salida esperada (`COMPUTE`, `IF`, `PERFORM`, `DISPLAY`).
30- 14 tests del fuente emitido; fuera de alcance v1: grupos como campo,
31  `REDEFINES`, `OCCURS`, `PERFORM ... THRU` como rango, E/S.
32
33### feat(charka-runtime): soporte de ejecución — campos Num y Text
34
35Crate nuevo `crates/modules/charka/charka-runtime` — el soporte que los
36programas COBOL transpilados enlazan. `charka-codegen` no emitirá Rust
37autónomo: emitirá Rust que llama a esta biblioteca.
38
39- `Num` — campo numérico (`PIC 9(5)V99`): un `Decimal` conformado a su
40  `Picture`. `store` trunca a la escala declarada; `store_rounded`
41  redondea; al desbordar la parte entera conserva los dígitos de bajo
42  orden (el `ON SIZE ERROR` de COBOL sin cláusula). `display` da los
43  dígitos con relleno de ceros y signo si corresponde.
44- `Text` — campo alfanumérico (`PIC X(n)`) de longitud fija: `store`
45  justifica a la izquierda y rellena con espacios o trunca; `fill`
46  mueve las constantes figurativas (`SPACES`, `ZEROS`).
47- `cobol_text_cmp` — comparación alfanumérica que rellena el más corto
48  con espacios.
49- Reexporta `Decimal`/`Picture`/`Rounding` de `charka-bcd`.
50- Construido antes que `charka-codegen` (la nota de orden del plan los
51  listaba al revés): el codegen emite contra esta API, así que el
52  runtime debe existir primero — y se verifica solo, sin el codegen.
53- 17 tests: campo en cero, `VALUE` inicial, truncado y redondeo,
54  desbordamiento que conserva bajo orden, magnitud sin signo y signo
55  con signo, justificación y relleno de texto, `fill`, comparación.
56
57### feat(charka-ir): representación intermedia — statements tipados
58
59Crate nuevo `crates/modules/charka/charka-ir` — la tercera etapa del
60pipeline: `Program` → `Ir`. El PROCEDURE division pasa de sentencias
61con tokens crudos a un árbol de instrucciones tipadas.
62
63- `lower(&Program) -> Ir` — total y tolerante: nunca falla.
64- `Ir { program_id, data, procedures }`. El modelo de datos (la DATA
65  division) pasa tal cual — sirve de tabla de símbolos.
66- `Stmt` cubre `MOVE`, `DISPLAY`, `ACCEPT`, `COMPUTE`, `ADD`,
67  `SUBTRACT`, `MULTIPLY`, `DIVIDE`, `IF`/`ELSE`/`END-IF`, `PERFORM`
68  (fuera de línea, en línea, `TIMES`, `UNTIL`), `GO TO`, `STOP RUN`,
69  `GOBACK`, `EXIT`, `CONTINUE`.
70- Expresiones de `COMPUTE` con precedencia y paréntesis (`+ -` <
71  `* /` < `**` asociativo a derecha). Condiciones de `IF`/`UNTIL` con
72  comparadores en forma símbolo (`= < > <= >= <>`) o palabra
73  (`EQUAL TO`, `GREATER THAN`...), `AND`/`OR`/`NOT` y nombres de
74  condición (datos de nivel 88).
75- COBOL no termina los statements con un símbolo: el parser delimita
76  las listas de operandos con palabras "frontera" (verbos,
77  terminadores `END-*`/`ELSE`, conectores `TO`/`GIVING`/`BY`...).
78- Un verbo no soportado se conserva como `Stmt::Unknown { verb,
79  tokens }` — el lowering nunca aborta.
80- Fuera de alcance v1: `EVALUATE`, `STRING`/`UNSTRING`, E/S de
81  ficheros, `PERFORM VARYING`, CICS, SQL embebido.
82- 17 tests: MOVE simple y multi-destino, DISPLAY con figurativas,
83  precedencia de COMPUTE, flag ROUNDED, ADD in-place vs GIVING,
84  SUBTRACT, DIVIDE BY/INTO, IF/ELSE, condiciones con AND, nombre de
85  condición, PERFORM párrafo/TIMES/UNTIL en línea, varios statements
86  en una sentencia, verbo desconocido, programa completo.
87
88### feat(charka-parser): parser COBOL'85 → AST
89
90Crate nuevo `crates/modules/charka/charka-parser` — la segunda etapa del
91pipeline: `Vec<Token>` → `Program` (AST). Alcance v1: el esqueleto del
92programa.
93
94- `parse(&[Token]) -> Result<Program, ParseError>`. El AST: `Program`
95  (`program_id`, `data`, `paragraphs`), `DataItem`, `Paragraph`,
96  `Sentence`.
97- Particiona el flujo de tokens en las cuatro divisiones por sus
98  encabezados (`X DIVISION`); de la IDENTIFICATION extrae el
99  `PROGRAM-ID`.
100- **DATA division** → árbol de `DataItem`: número de nivel, nombre,
101  cláusula `PICTURE` reensamblada (`S9` `(` `5` `)` `V99` →
102  `S9(5)V99`) y `VALUE`. Anida por número de nivel — 01 y 77 son
103  raíces, 88 cuelga del ítem precedente.
104- **PROCEDURE division** → `Vec<Paragraph>`, cada párrafo con sus
105  `Sentence` (tokens crudos; sin parseo a nivel de statement, eso es
106  `charka-ir`). Las sentencias previas al primer encabezado van a un
107  párrafo implícito de nombre "".
108- Parser tolerante: salta encabezados de `SECTION`, entradas `FD`/`SD`
109  y cláusulas de datos que no sean `PICTURE`/`VALUE`. `ParseError` sólo
110  ante un número de nivel inválido o un dato sin nombre.
111- 15 tests: PROGRAM-ID (forma larga y `ID` corta), ítems planos y
112  anidados, reensamblado de PICTURE, variantes de VALUE, niveles 88,
113  `FILLER`, párrafos y párrafo implícito, encabezado de sección,
114  programa completo de punta a punta, nivel inválido.
115
116### feat(charka-lexer): tokenizador de COBOL
117
118Crate nuevo `crates/modules/charka/charka-lexer` — la primera etapa del
119pipeline del transpilador: texto COBOL → secuencia de `Token`.
120
121- **Lexer deliberadamente tonto**: no conoce keywords ni la cláusula
122  `PICTURE`; emite `Word` para todo identificador y deja la
123  clasificación al parser.
124- Tokens: `Word` (palabras COBOL con guiones internos), `Number`
125  (literal sin signo), `String` (comillas dobladas colapsadas),
126  `Period` (el `.` terminador), `Symbol` (paréntesis, separadores y
127  operadores `+ - * / ** = < > <= >= <>`).
128- Dos formatos de fuente: **fijo** (la tarjeta de 80 columnas — cols
129  1-6 secuencia, 7 indicadora, 8-72 código, 73-80 identificación) y
130  **libre**. Comentarios por la columna indicadora (`*`/`/`) o por `*`
131  inicial en formato libre.
132- Cada `Token` lleva línea y columna 1-based; `LexError` tipado
133  (literal sin cerrar, carácter inesperado).
134- Limitación v1 documentada: no soporta continuación de literales entre
135  líneas (indicador `-`). Subconjunto COBOL'85, el hito intermedio.
136- 17 tests: sentencias, palabras con guiones, literales y comillas
137  dobladas, números vs terminador, operadores, ambos formatos,
138  tracking de posición, errores.
139
140### feat(charka-bcd): aritmética decimal con semántica COBOL
141
142(Pre-existente.) `Picture` + `Decimal` de punto fijo exacto — ver el
143SDD del módulo. 22 tests.