1# modules/charka/ — Transpilador COBOL → Rust
2
3**Propósito.** Modernizar sistemas COBOL legados transpilándolos a Rust
4con un runtime determinista y un validador en sombra (shadow validator)
5que compara la salida del original y la del transpilado. Es el módulo
6más grande del ecosistema — el parser COBOL completo (CICS, SQL
7embebido, dialectos IBM Enterprise) es un esfuerzo multi-mes.
8
9## Crates
10
11| crate          | tipo | rol                                                          |
12| -------------- | ---- | ------------------------------------------------------------ |
13| `charka-bcd`    | lib  | Aritmética decimal de punto fijo con semántica COBOL: `Picture`, `Decimal`, redondeo, `ON SIZE ERROR` |
14| `charka-lexer`  | lib  | Tokenizador COBOL: formato fijo (tarjeta de 80 columnas) y libre |
15| `charka-parser`  | lib  | Parser COBOL'85 (subconjunto): tokens → AST (`Program`) |
16| `charka-ir`      | lib  | Representación intermedia: el AST con los statements del PROCEDURE ya tipados |
17| `charka-runtime` | lib  | Soporte de ejecución de los programas transpilados: campos `Num` y `Text` |
18| `charka-codegen` | lib  | Emisión de Rust: IR → fuente Rust sobre `charka-runtime` |
19
20## charka-bcd
21
22COBOL no calcula en binario flotante: opera sobre campos decimales de
23precisión fija (`PIC S9(5)V99`). Reproducir un programa COBOL exige
24reproducir esa aritmética dígito a dígito.
25
26- `Picture` — parsea la cláusula PICTURE numérica (`9`, `V`, `S`, `9(n)`).
27- `Decimal` — punto fijo exacto (`mantissa: i128` + `scale`); suma, resta
28  y producto exactos; división con escala de resultado fija; redondeo
29  `Truncate`/`HalfUp`; `coerce` a un `Picture` con detección de
30  desbordamiento.
31- Determinista, sin dependencias de plataforma — mismo programa, mismos
32  dígitos, en cualquier máquina.
33
34## charka-lexer
35
36Primera etapa del pipeline: texto COBOL → secuencia de `Token`.
37
38- **Lexer tonto**: no conoce keywords ni la cláusula `PICTURE` — emite
39  `Word` para todo identificador; la clasificación es del parser.
40- Tokens: `Word` (con guiones internos, `WORKING-STORAGE`), `Number`
41  (sin signo), `String` (comillas dobladas colapsadas), `Period`,
42  `Symbol` (`( ) , ; :` y operadores `+ - * / ** = < > <= >= <>`).
43- Dos formatos: **fijo** (cols 1-6 secuencia, 7 indicadora, 8-72
44  código, 73-80 id) y **libre**. Comentarios por col 7 (`*`/`/`) o `*`
45  inicial en formato libre.
46- Cada token lleva línea/columna 1-based. `LexError` tipado.
47- Limitación v1: sin continuación de literales entre líneas
48  (indicador `-`).
49
50## charka-parser
51
52Segunda etapa: tokens → AST. Alcance v1 — el **esqueleto del programa**.
53
54- `parse(&[Token]) -> Result<Program, ParseError>`.
55- `Program { program_id, data: Vec<DataItem>, paragraphs: Vec<Paragraph> }`.
56- **DATA division** → árbol de `DataItem` (`level`, `name`, `picture`,
57  `value`, `children`). Reensambla la cláusula `PICTURE` desde sus
58  tokens (`S9` `(` `5` `)` `V99` → `S9(5)V99`); anida por número de
59  nivel (01 y 77 son raíces; 88 cuelga del ítem precedente).
60- **PROCEDURE division** → `Vec<Paragraph>`, cada `Paragraph` con sus
61  `Sentence` (tokens crudos — sin parseo a nivel de statement). Las
62  sentencias previas al primer encabezado van a un párrafo implícito
63  de nombre "".
64- Tolerante: salta encabezados de `SECTION`, entradas `FD`/`SD` y
65  cláusulas de datos que no sean `PICTURE`/`VALUE`. `ParseError` sólo
66  ante nivel inválido o dato sin nombre.
67- Limitación v1: no parsea statements, ni la ENVIRONMENT division, ni
68  CICS / SQL embebido / dialectos IBM.
69
70## charka-ir
71
72Tercera etapa: `Program` → `Ir`. Aquí se parsea cada `Sentence` cruda
73(tokens) a statements tipados — el PROCEDURE division pasa de tokens a
74árbol de instrucciones.
75
76- `lower(&Program) -> Ir` — **total y tolerante**, nunca falla.
77- `Ir { program_id, data: Vec<DataItem>, procedures: Vec<Procedure> }`.
78  El modelo de datos pasa tal cual (sirve de tabla de símbolos).
79- `Procedure { name, body: Vec<Stmt> }`. `Stmt` cubre `Move`,
80  `Display`, `Accept`, `Compute`, `Add`/`Subtract`/`Multiply`/`Divide`,
81  `If`, `Perform`, `GoTo`, `StopRun`, `Goback`, `Exit`, `Continue`.
82- `Expr` — expresiones aritméticas con precedencia y paréntesis (Pratt:
83  `+ -` < `* /` < `**` der.). `Cond` — comparaciones (símbolo o forma
84  palabra) unidas por `AND`/`OR`/`NOT`, más nombres de condición (88).
85- Un verbo no soportado se conserva como `Stmt::Unknown { verb,
86  tokens }` — el lowering jamás aborta.
87- COBOL no separa statements con un símbolo: cada uno corta donde
88  empieza el verbo del siguiente. El parser usa palabras "frontera"
89  (verbos + terminadores `END-*`/`ELSE` + conectores `TO`/`GIVING`...)
90  para delimitar listas de operandos.
91- Fuera de alcance v1: `EVALUATE`, `STRING`/`UNSTRING`, E/S de
92  ficheros, `PERFORM VARYING`, CICS, SQL embebido.
93
94## charka-runtime
95
96El soporte de ejecución: lo que `charka-codegen` emite es Rust que
97enlaza contra este crate. Da a un programa transpilado la semántica de
98COBOL en tiempo de ejecución.
99
100- `Num` — campo numérico (`PIC 9(5)V99`): un `Decimal` conformado a su
101  `Picture`. `store`/`store_rounded` truncan o redondean a la escala
102  declarada; al desbordar conservan los dígitos de bajo orden (el
103  `ON SIZE ERROR` sin cláusula). `display` da los dígitos con relleno
104  de ceros.
105- `Text` — campo alfanumérico (`PIC X(20)`) de longitud fija: `store`
106  justifica a la izquierda y rellena/trunca; `fill` mueve figurativas
107  (`SPACES`, `ZEROS`).
108- `cobol_text_cmp` — comparación alfanumérica con relleno de espacios.
109- Reexporta `Decimal`/`Picture`/`Rounding` de `charka-bcd` para que el
110  código generado sólo necesite `use charka_runtime::*;`.
111
112Construido **antes** que `charka-codegen` (la nota de orden del plan
113los listaba al revés): el codegen emite llamadas contra esta API, así
114que el runtime debe existir primero — y es un crate autocontenido,
115verificable sin depender del código emitido.
116
117## charka-codegen
118
119La etapa final: `generate(&Ir) -> String` produce un fuente Rust (un
120`main.rs`) que, compilado contra `charka-runtime`, ejecuta la lógica
121del programa COBOL.
122
123- Un `struct Program` con un campo por cada dato elemental (`Num` /
124  `Text`); `Program::new()` lo inicializa desde las cláusulas `VALUE`.
125- Un método `p_<párrafo>(&mut self)` por párrafo; `run()` los encadena
126  en orden (el «caer» de COBOL); `main()` construye y corre.
127- Cada `Stmt` → líneas Rust: `MOVE`→`.store`, `DISPLAY`→`println!`,
128  `COMPUTE`/aritmética → expresiones `Decimal`, `IF`→`if`, `PERFORM`→
129  llamada / `for` / `while`, `STOP RUN`→`process::exit`.
130- **Tolerante**: lo no transpilable (`Stmt::Unknown`, dato sin
131  resolver, `**`) se emite como comentario `// charka:` — el código
132  generado siempre compila.
133- Verificado de punta a punta: un programa COBOL de demostración
134  transpila a Rust que compila contra `charka-runtime` y produce la
135  salida correcta.
136- Fuera de alcance v1: grupos como campo propio, `REDEFINES`,
137  `OCCURS`/tablas, `PERFORM ... THRU` como rango, E/S de ficheros.
138
139## Estado
140
141`charka-bcd` (22 tests), `charka-lexer` (17 tests), `charka-parser`
142(15 tests), `charka-ir` (17 tests), `charka-runtime` (17 tests) y
143`charka-codegen` (14 tests) implementados y verdes. El pipeline
144COBOL→Rust corre de punta a punta. **Pendiente** — el último crate:
145
146| crate pendiente   | rol                                                  |
147| ----------------- | ---------------------------------------------------- |
148| `charka-shadow`   | validador en sombra (original vs transpilado)        |
149
150Hito intermedio sugerido: subconjunto COBOL'85 puro antes de CICS/SQL.