sergio
b3278bdb0c
El gran hueco que faltaba para el COBOL real: el procesamiento de ficheros secuenciales. Una rebanada vertical por los seis crates. - charka-parser: la ENVIRONMENT division ya no se ignora — se parsea FILE-CONTROL (SELECT name ASSIGN TO "ruta"); del FILE SECTION se asocia cada FD con su registro 01. Program::files. - charka-runtime: tipo CobFile — un fichero «line sequential» (cada registro una línea). Lectura: carga a memoria. Escritura: acumula y vuelca al cerrar. - charka-ir: Ir::files y los statements Open/Close/Read/Write. READ lleva sus bloques AT END / NOT AT END. - charka-codegen: un campo CobFile por fichero en el struct Program; los verbos emiten llamadas al runtime. - charka-shadow: el intérprete hace E/S de ficheros real. - Corpus: programa nuevo 18-fichero — escribe tres líneas, las relee con READ ... AT END y las muestra. Verificado: el intérprete sombra y el crate compilado por scaffold dan la misma salida. Alcance v1: organización line sequential; sin ficheros indexados ni relativos, sin FILE STATUS. Tests: charka-parser 17, charka-runtime 19, charka-ir 30, charka-codegen 25, charka-shadow 23. fmt + clippy limpios. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
824 lines
27 KiB
Rust
824 lines
27 KiB
Rust
//! `charka-parser` — parser de COBOL'85 (subconjunto) a AST.
|
|
//!
|
|
//! Segunda etapa del transpilador COBOL→Rust: consume los [`Token`] del
|
|
//! `charka-lexer` y produce un [`Program`]. El alcance de la v1 es el
|
|
//! **esqueleto del programa**:
|
|
//!
|
|
//! - Las cuatro divisiones (`IDENTIFICATION`, `ENVIRONMENT`, `DATA`,
|
|
//! `PROCEDURE`) y el `PROGRAM-ID`.
|
|
//! - La **DATA division** como un árbol de [`DataItem`]: número de
|
|
//! nivel, nombre, cláusula `PICTURE` reensamblada y `VALUE`.
|
|
//! - La **PROCEDURE division** como una lista de [`Paragraph`], cada
|
|
//! uno con sus [`Sentence`] (los tokens crudos de cada sentencia).
|
|
//!
|
|
//! Lo que **no** hace todavía: el parseo a nivel de statement (cada
|
|
//! sentencia queda como `Vec<Token>` — es trabajo de `charka-ir`), la
|
|
//! ENVIRONMENT division, CICS, SQL embebido y los dialectos IBM. Son
|
|
//! las etapas siguientes del plan.
|
|
//!
|
|
//! El parser es tolerante: salta lo que no entiende (encabezados de
|
|
//! `SECTION`, entradas `FD`/`SD`, cláusulas de datos que no sean
|
|
//! `PICTURE`/`VALUE`) en vez de fallar. Sólo emite [`ParseError`] ante
|
|
//! un número de nivel inválido o un dato sin nombre.
|
|
|
|
#![forbid(unsafe_code)]
|
|
|
|
use thiserror::Error;
|
|
|
|
pub use charka_lexer::{Token, TokenKind};
|
|
|
|
/// Un programa COBOL parseado: el esqueleto de sus cuatro divisiones.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Default)]
|
|
pub struct Program {
|
|
/// El `PROGRAM-ID` de la IDENTIFICATION division, si está presente.
|
|
pub program_id: Option<String>,
|
|
/// Los ítems raíz de la DATA division (cada `01`/`77` con su árbol).
|
|
pub data: Vec<DataItem>,
|
|
/// Los ficheros declarados (`SELECT` + `FD`).
|
|
pub files: Vec<FileEntry>,
|
|
/// Los párrafos de la PROCEDURE division, en orden de aparición.
|
|
pub paragraphs: Vec<Paragraph>,
|
|
}
|
|
|
|
/// Un fichero declarado: su nombre lógico, la ruta a la que se asigna
|
|
/// (`ASSIGN TO`) y el dato de registro asociado (el `01` bajo su `FD`).
|
|
#[derive(Debug, Clone, PartialEq, Eq, Default)]
|
|
pub struct FileEntry {
|
|
pub name: String,
|
|
pub path: String,
|
|
pub record: String,
|
|
}
|
|
|
|
/// Un ítem de datos de la DATA division: un número de nivel, un nombre
|
|
/// y, opcionalmente, las cláusulas `PICTURE` y `VALUE`. Los ítems de
|
|
/// mayor nivel numérico cuelgan como `children` del que los contiene.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct DataItem {
|
|
/// Número de nivel: 01-49 (jerárquico), 66 (`RENAMES`), 77
|
|
/// (elemental independiente) u 88 (nombre de condición).
|
|
pub level: u8,
|
|
/// Nombre del dato, normalizado a mayúsculas (`FILLER` incluido).
|
|
pub name: String,
|
|
/// Cláusula `PICTURE` reensamblada (`S9(5)V99`), si la hay.
|
|
pub picture: Option<String>,
|
|
/// Cláusula `VALUE`: literal numérico (con signo), constante
|
|
/// figurativa en mayúsculas, o literal de texto entre comillas.
|
|
pub value: Option<String>,
|
|
/// Cláusula `OCCURS n [TIMES]`: el dato es una tabla de `n`
|
|
/// elementos. `None` si es un dato escalar.
|
|
pub occurs: Option<u32>,
|
|
/// Ítems subordinados (de nivel numérico mayor).
|
|
pub children: Vec<DataItem>,
|
|
}
|
|
|
|
/// Un párrafo de la PROCEDURE division. El párrafo implícito que
|
|
/// agrupa las sentencias previas al primer encabezado tiene `name` "".
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Paragraph {
|
|
/// Nombre del párrafo en mayúsculas; "" para el párrafo implícito.
|
|
pub name: String,
|
|
/// Sentencias del párrafo, en orden.
|
|
pub sentences: Vec<Sentence>,
|
|
}
|
|
|
|
/// Una sentencia: los tokens entre dos puntos terminadores. La v1 no
|
|
/// parsea a nivel de statement — eso es trabajo de `charka-ir`.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Sentence {
|
|
pub tokens: Vec<Token>,
|
|
}
|
|
|
|
/// Error de parseo, con la línea del token donde se detectó.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Error)]
|
|
pub enum ParseError {
|
|
#[error("línea {line}: número de nivel inválido {found:?} (esperado 01-49, 66, 77 u 88)")]
|
|
BadLevel { line: u32, found: String },
|
|
#[error("línea {line}: se esperaba el nombre de un dato tras el número de nivel")]
|
|
ExpectedDataName { line: u32 },
|
|
}
|
|
|
|
/// Las cuatro divisiones de un programa COBOL.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum DivKind {
|
|
Identification,
|
|
Environment,
|
|
Data,
|
|
Procedure,
|
|
}
|
|
|
|
/// Parsea una secuencia de tokens COBOL en un [`Program`].
|
|
pub fn parse(tokens: &[Token]) -> Result<Program, ParseError> {
|
|
let divs = find_divisions(tokens);
|
|
let mut program = Program::default();
|
|
for (idx, &(kind, start)) in divs.iter().enumerate() {
|
|
// El cuerpo de la división va desde el punto que cierra su
|
|
// encabezado hasta el comienzo de la división siguiente.
|
|
let lo = match period_after(tokens, start) {
|
|
Some(p) => p + 1,
|
|
None => tokens.len(),
|
|
};
|
|
let next = divs.get(idx + 1).map(|&(_, s)| s).unwrap_or(tokens.len());
|
|
let body = &tokens[lo..next.max(lo)];
|
|
match kind {
|
|
DivKind::Identification => parse_identification(body, &mut program),
|
|
DivKind::Environment => parse_environment(body, &mut program),
|
|
DivKind::Data => {
|
|
let (data, fd_records) = parse_data(body)?;
|
|
program.data = data;
|
|
// Asocia cada `FD` con el registro `01` que le sigue.
|
|
for (fd, record) in fd_records {
|
|
if let Some(f) = program.files.iter_mut().find(|f| f.name == fd) {
|
|
f.record = record;
|
|
}
|
|
}
|
|
}
|
|
DivKind::Procedure => program.paragraphs = parse_procedure(body),
|
|
}
|
|
}
|
|
Ok(program)
|
|
}
|
|
|
|
/// Localiza los encabezados de división (`X DIVISION`) y devuelve, en
|
|
/// orden, su clase y el índice del token de la palabra de división.
|
|
fn find_divisions(tokens: &[Token]) -> Vec<(DivKind, usize)> {
|
|
let mut divs = Vec::new();
|
|
let mut i = 0;
|
|
while i + 1 < tokens.len() {
|
|
if kw(tokens.get(i + 1)).as_deref() == Some("DIVISION") {
|
|
let kind = match kw(tokens.get(i)).as_deref() {
|
|
Some("IDENTIFICATION") | Some("ID") => Some(DivKind::Identification),
|
|
Some("ENVIRONMENT") => Some(DivKind::Environment),
|
|
Some("DATA") => Some(DivKind::Data),
|
|
Some("PROCEDURE") => Some(DivKind::Procedure),
|
|
_ => None,
|
|
};
|
|
if let Some(k) = kind {
|
|
divs.push((k, i));
|
|
i += 2;
|
|
continue;
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
divs
|
|
}
|
|
|
|
/// Extrae el `PROGRAM-ID` del cuerpo de la IDENTIFICATION division.
|
|
fn parse_identification(body: &[Token], program: &mut Program) {
|
|
for (i, t) in body.iter().enumerate() {
|
|
if kw(Some(t)).as_deref() == Some("PROGRAM-ID") {
|
|
// `PROGRAM-ID. NAME.` — el punto tras `PROGRAM-ID` es opcional.
|
|
let mut j = i + 1;
|
|
if body.get(j).map(|t| t.kind) == Some(TokenKind::Period) {
|
|
j += 1;
|
|
}
|
|
if let Some(name) = body.get(j) {
|
|
program.program_id = Some(match name.kind {
|
|
TokenKind::Word => name.text.to_uppercase(),
|
|
TokenKind::String => name.text.clone(),
|
|
_ => continue,
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Parsea el cuerpo de la DATA division en un árbol de [`DataItem`].
|
|
/// Parsea la cláusula `FILE-CONTROL` de la ENVIRONMENT division: cada
|
|
/// `SELECT name ASSIGN TO "ruta"` se registra como un fichero.
|
|
fn parse_environment(body: &[Token], program: &mut Program) {
|
|
for sent in split_sentences(body) {
|
|
if kw(sent.first()).as_deref() != Some("SELECT") {
|
|
continue;
|
|
}
|
|
let Some(name_tok) = sent.get(1) else {
|
|
continue;
|
|
};
|
|
if name_tok.kind != TokenKind::Word {
|
|
continue;
|
|
}
|
|
let mut path = String::new();
|
|
let mut i = 2;
|
|
while i < sent.len() {
|
|
if kw(sent.get(i)).as_deref() == Some("ASSIGN") {
|
|
i += 1;
|
|
if kw(sent.get(i)).as_deref() == Some("TO") {
|
|
i += 1;
|
|
}
|
|
if let Some(t) = sent.get(i) {
|
|
path = t.text.clone();
|
|
}
|
|
break;
|
|
}
|
|
i += 1;
|
|
}
|
|
program.files.push(FileEntry {
|
|
name: name_tok.text.to_uppercase(),
|
|
path,
|
|
record: String::new(),
|
|
});
|
|
}
|
|
}
|
|
|
|
/// El resultado de parsear la DATA division: el árbol de datos y las
|
|
/// parejas `(FD, registro)` — el `01` que sigue a cada `FD`.
|
|
type DataResult = (Vec<DataItem>, Vec<(String, String)>);
|
|
|
|
/// Parsea la DATA division.
|
|
fn parse_data(body: &[Token]) -> Result<DataResult, ParseError> {
|
|
let mut flat = Vec::new();
|
|
let mut fd_records = Vec::new();
|
|
let mut pending_fd: Option<String> = None;
|
|
for sent in split_sentences(body) {
|
|
let Some(first) = sent.first() else { continue };
|
|
// Las sentencias que arrancan con un número de nivel son
|
|
// entradas de datos; las demás son encabezados de SECTION o
|
|
// de `FD`/`SD`.
|
|
if first.kind != TokenKind::Number {
|
|
if matches!(kw(Some(first)).as_deref(), Some("FD") | Some("SD")) {
|
|
pending_fd = sent
|
|
.get(1)
|
|
.filter(|t| t.kind == TokenKind::Word)
|
|
.map(|t| t.text.to_uppercase());
|
|
}
|
|
continue;
|
|
}
|
|
let level = parse_level(first)?;
|
|
let entry = parse_data_entry(level, &sent)?;
|
|
// El primer `01` tras un `FD` es su registro.
|
|
if level == 1 {
|
|
if let Some(fd) = pending_fd.take() {
|
|
fd_records.push((fd, entry.name.clone()));
|
|
}
|
|
}
|
|
flat.push(entry);
|
|
}
|
|
Ok((build_tree(flat), fd_records))
|
|
}
|
|
|
|
/// Valida que el token sea un número de nivel COBOL (01-49, 66, 77, 88).
|
|
fn parse_level(t: &Token) -> Result<u8, ParseError> {
|
|
let bad = || ParseError::BadLevel {
|
|
line: t.line,
|
|
found: t.text.clone(),
|
|
};
|
|
let n: u8 = t.text.parse().map_err(|_| bad())?;
|
|
if (1..=49).contains(&n) || n == 66 || n == 77 || n == 88 {
|
|
Ok(n)
|
|
} else {
|
|
Err(bad())
|
|
}
|
|
}
|
|
|
|
/// Parsea una sola entrada de datos (una sentencia ya sin el punto).
|
|
fn parse_data_entry(level: u8, sent: &[Token]) -> Result<DataItem, ParseError> {
|
|
let line = sent[0].line;
|
|
let name_tok = sent.get(1).ok_or(ParseError::ExpectedDataName { line })?;
|
|
if name_tok.kind != TokenKind::Word {
|
|
return Err(ParseError::ExpectedDataName {
|
|
line: name_tok.line,
|
|
});
|
|
}
|
|
let name = name_tok.text.to_uppercase();
|
|
|
|
let mut picture = None;
|
|
let mut value = None;
|
|
let mut occurs = None;
|
|
let mut i = 2;
|
|
while i < sent.len() {
|
|
match kw(sent.get(i)).as_deref() {
|
|
Some("OCCURS") => {
|
|
i += 1;
|
|
if let Some(t) = sent.get(i) {
|
|
if t.kind == TokenKind::Number {
|
|
if occurs.is_none() {
|
|
occurs = t.text.parse::<u32>().ok();
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
if kw(sent.get(i)).as_deref() == Some("TIMES") {
|
|
i += 1;
|
|
}
|
|
}
|
|
Some("PIC") | Some("PICTURE") => {
|
|
i += 1;
|
|
if kw(sent.get(i)).as_deref() == Some("IS") {
|
|
i += 1;
|
|
}
|
|
let (pic, next) = collect_picture(sent, i);
|
|
if picture.is_none() && !pic.is_empty() {
|
|
picture = Some(pic);
|
|
}
|
|
i = next;
|
|
}
|
|
Some("VALUE") => {
|
|
i += 1;
|
|
if matches!(kw(sent.get(i)).as_deref(), Some("IS") | Some("ARE")) {
|
|
i += 1;
|
|
}
|
|
let (val, next) = collect_value(sent, i);
|
|
if value.is_none() {
|
|
value = val;
|
|
}
|
|
i = next;
|
|
}
|
|
_ => i += 1,
|
|
}
|
|
}
|
|
|
|
Ok(DataItem {
|
|
level,
|
|
name,
|
|
picture,
|
|
value,
|
|
occurs,
|
|
children: Vec::new(),
|
|
})
|
|
}
|
|
|
|
/// Reensambla la cláusula PICTURE: concatena el texto de los tokens
|
|
/// (`S9` `(` `5` `)` `V99` → `S9(5)V99`) hasta toparse con otra
|
|
/// cláusula de datos. El resultado va en mayúsculas.
|
|
fn collect_picture(sent: &[Token], start: usize) -> (String, usize) {
|
|
let mut s = String::new();
|
|
let mut i = start;
|
|
while let Some(t) = sent.get(i) {
|
|
if let Some(w) = kw(Some(t)) {
|
|
if is_data_clause_kw(&w) {
|
|
break;
|
|
}
|
|
}
|
|
s.push_str(&t.text);
|
|
i += 1;
|
|
}
|
|
(s.to_uppercase(), i)
|
|
}
|
|
|
|
/// Captura el literal de una cláusula VALUE: un signo opcional seguido
|
|
/// de un número, una constante figurativa o un literal de texto (que se
|
|
/// devuelve entre comillas simples para distinguirlo de una palabra).
|
|
fn collect_value(sent: &[Token], start: usize) -> (Option<String>, usize) {
|
|
let mut i = start;
|
|
let mut s = String::new();
|
|
if let Some(t) = sent.get(i) {
|
|
if t.kind == TokenKind::Symbol && (t.text == "+" || t.text == "-") {
|
|
s.push_str(&t.text);
|
|
i += 1;
|
|
}
|
|
}
|
|
if let Some(t) = sent.get(i) {
|
|
match t.kind {
|
|
TokenKind::Number => {
|
|
s.push_str(&t.text);
|
|
i += 1;
|
|
}
|
|
TokenKind::String => {
|
|
s.push('\'');
|
|
s.push_str(&t.text);
|
|
s.push('\'');
|
|
i += 1;
|
|
}
|
|
TokenKind::Word => {
|
|
// Constante figurativa: ZERO, ZEROS, SPACE, SPACES,
|
|
// HIGH-VALUE, LOW-VALUE, QUOTES, NULL...
|
|
s.push_str(&t.text.to_uppercase());
|
|
i += 1;
|
|
}
|
|
TokenKind::Period | TokenKind::Symbol => {}
|
|
}
|
|
}
|
|
if s.is_empty() {
|
|
(None, i)
|
|
} else {
|
|
(Some(s), i)
|
|
}
|
|
}
|
|
|
|
/// ¿Es `w` una palabra que abre una cláusula de datos? Marca el final
|
|
/// de la cláusula PICTURE.
|
|
fn is_data_clause_kw(w: &str) -> bool {
|
|
matches!(
|
|
w,
|
|
"VALUE"
|
|
| "OCCURS"
|
|
| "REDEFINES"
|
|
| "RENAMES"
|
|
| "USAGE"
|
|
| "COMP"
|
|
| "COMP-1"
|
|
| "COMP-2"
|
|
| "COMP-3"
|
|
| "COMP-4"
|
|
| "COMP-5"
|
|
| "COMPUTATIONAL"
|
|
| "COMPUTATIONAL-1"
|
|
| "COMPUTATIONAL-2"
|
|
| "COMPUTATIONAL-3"
|
|
| "COMPUTATIONAL-4"
|
|
| "COMPUTATIONAL-5"
|
|
| "BINARY"
|
|
| "PACKED-DECIMAL"
|
|
| "SIGN"
|
|
| "JUSTIFIED"
|
|
| "JUST"
|
|
| "BLANK"
|
|
| "SYNCHRONIZED"
|
|
| "SYNC"
|
|
| "DISPLAY"
|
|
)
|
|
}
|
|
|
|
/// Convierte la lista plana de ítems en un árbol según los niveles: un
|
|
/// ítem cuelga del anterior cuyo nivel sea estrictamente menor. Los
|
|
/// niveles 01 y 77 son siempre raíces.
|
|
fn build_tree(flat: Vec<DataItem>) -> Vec<DataItem> {
|
|
let mut roots: Vec<DataItem> = Vec::new();
|
|
let mut stack: Vec<DataItem> = Vec::new();
|
|
for item in flat {
|
|
if item.level == 1 || item.level == 77 {
|
|
while let Some(done) = stack.pop() {
|
|
attach(&mut stack, &mut roots, done);
|
|
}
|
|
} else {
|
|
// Cerrar los hermanos y descendientes ya completos.
|
|
while stack.last().is_some_and(|top| top.level >= item.level) {
|
|
let done = stack.pop().unwrap();
|
|
attach(&mut stack, &mut roots, done);
|
|
}
|
|
}
|
|
stack.push(item);
|
|
}
|
|
while let Some(done) = stack.pop() {
|
|
attach(&mut stack, &mut roots, done);
|
|
}
|
|
roots
|
|
}
|
|
|
|
/// Engancha un ítem completo: como hijo del que esté en el tope de la
|
|
/// pila, o como raíz si la pila está vacía.
|
|
fn attach(stack: &mut [DataItem], roots: &mut Vec<DataItem>, item: DataItem) {
|
|
if let Some(parent) = stack.last_mut() {
|
|
parent.children.push(item);
|
|
} else {
|
|
roots.push(item);
|
|
}
|
|
}
|
|
|
|
/// Parsea el cuerpo de la PROCEDURE division en párrafos.
|
|
fn parse_procedure(body: &[Token]) -> Vec<Paragraph> {
|
|
let mut paras: Vec<Paragraph> = Vec::new();
|
|
let mut current = Paragraph {
|
|
name: String::new(),
|
|
sentences: Vec::new(),
|
|
};
|
|
let mut current_named = false;
|
|
for sent in split_sentences(body) {
|
|
if let Some(name) = paragraph_header_name(&sent) {
|
|
// Cerrar el párrafo en curso si tiene identidad o contenido.
|
|
if current_named || !current.sentences.is_empty() {
|
|
paras.push(std::mem::replace(
|
|
&mut current,
|
|
Paragraph {
|
|
name: String::new(),
|
|
sentences: Vec::new(),
|
|
},
|
|
));
|
|
}
|
|
current.name = name;
|
|
current_named = true;
|
|
} else {
|
|
current.sentences.push(Sentence { tokens: sent });
|
|
}
|
|
}
|
|
if current_named || !current.sentences.is_empty() {
|
|
paras.push(current);
|
|
}
|
|
paras
|
|
}
|
|
|
|
/// ¿Es esta sentencia un encabezado de párrafo o de sección? Lo es si
|
|
/// es una sola palabra (un nombre de párrafo) o `NOMBRE SECTION`. Se
|
|
/// excluyen `EXIT`/`GOBACK`/`CONTINUE`, que de una sola palabra son
|
|
/// statements, no encabezados.
|
|
fn paragraph_header_name(sent: &[Token]) -> Option<String> {
|
|
match sent {
|
|
[w] if w.kind == TokenKind::Word => {
|
|
let name = w.text.to_uppercase();
|
|
if matches!(name.as_str(), "EXIT" | "GOBACK" | "CONTINUE") {
|
|
None
|
|
} else {
|
|
Some(name)
|
|
}
|
|
}
|
|
[w, s] if w.kind == TokenKind::Word && kw(Some(s)).as_deref() == Some("SECTION") => {
|
|
Some(w.text.to_uppercase())
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Parte un tramo de tokens en sentencias por el punto terminador. El
|
|
/// punto se descarta; las sentencias vacías no se emiten.
|
|
fn split_sentences(body: &[Token]) -> Vec<Vec<Token>> {
|
|
let mut out = Vec::new();
|
|
let mut cur = Vec::new();
|
|
for t in body {
|
|
if t.kind == TokenKind::Period {
|
|
if !cur.is_empty() {
|
|
out.push(std::mem::take(&mut cur));
|
|
}
|
|
} else {
|
|
cur.push(t.clone());
|
|
}
|
|
}
|
|
if !cur.is_empty() {
|
|
out.push(cur);
|
|
}
|
|
out
|
|
}
|
|
|
|
/// El índice del primer `Period` en `tokens` a partir de `start`.
|
|
fn period_after(tokens: &[Token], start: usize) -> Option<usize> {
|
|
tokens
|
|
.iter()
|
|
.enumerate()
|
|
.skip(start)
|
|
.find(|(_, t)| t.kind == TokenKind::Period)
|
|
.map(|(i, _)| i)
|
|
}
|
|
|
|
/// Si el token es una palabra, su texto en mayúsculas (COBOL es
|
|
/// case-insensitive). `None` para cualquier otra clase de token o
|
|
/// posición ausente.
|
|
fn kw(t: Option<&Token>) -> Option<String> {
|
|
match t {
|
|
Some(t) if t.kind == TokenKind::Word => Some(t.text.to_uppercase()),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use charka_lexer::{lex, SourceFormat};
|
|
|
|
/// Helper: lexa el fuente en formato libre y lo parsea.
|
|
fn parse_src(src: &str) -> Program {
|
|
let toks = lex(src, SourceFormat::Free).expect("lex OK");
|
|
parse(&toks).expect("parse OK")
|
|
}
|
|
|
|
#[test]
|
|
fn empty_input_yields_empty_program() {
|
|
let p = parse(&[]).unwrap();
|
|
assert_eq!(p, Program::default());
|
|
assert!(p.program_id.is_none());
|
|
assert!(p.data.is_empty());
|
|
assert!(p.paragraphs.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn captures_program_id() {
|
|
let p = parse_src(
|
|
"IDENTIFICATION DIVISION.\n\
|
|
PROGRAM-ID. PAYROLL.\n",
|
|
);
|
|
assert_eq!(p.program_id.as_deref(), Some("PAYROLL"));
|
|
}
|
|
|
|
#[test]
|
|
fn id_division_short_form_and_case_normalized() {
|
|
let p = parse_src("ID DIVISION.\nPROGRAM-ID. hello.\n");
|
|
assert_eq!(p.program_id.as_deref(), Some("HELLO"));
|
|
}
|
|
|
|
#[test]
|
|
fn flat_data_items() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
77 WS-COUNT PIC 9(3) VALUE 0.\n\
|
|
77 WS-NAME PIC X(20).\n",
|
|
);
|
|
assert_eq!(p.data.len(), 2);
|
|
assert_eq!(p.data[0].name, "WS-COUNT");
|
|
assert_eq!(p.data[0].level, 77);
|
|
assert_eq!(p.data[0].picture.as_deref(), Some("9(3)"));
|
|
assert_eq!(p.data[0].value.as_deref(), Some("0"));
|
|
assert_eq!(p.data[1].name, "WS-NAME");
|
|
assert_eq!(p.data[1].picture.as_deref(), Some("X(20)"));
|
|
assert!(p.data[1].value.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn data_item_nesting() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 CUSTOMER-RECORD.\n\
|
|
05 CUST-NAME PIC X(20).\n\
|
|
05 CUST-ADDR.\n\
|
|
10 STREET PIC X(30).\n\
|
|
10 CITY PIC X(20).\n",
|
|
);
|
|
assert_eq!(p.data.len(), 1);
|
|
let rec = &p.data[0];
|
|
assert_eq!(rec.name, "CUSTOMER-RECORD");
|
|
assert_eq!(rec.children.len(), 2);
|
|
assert_eq!(rec.children[0].name, "CUST-NAME");
|
|
let addr = &rec.children[1];
|
|
assert_eq!(addr.name, "CUST-ADDR");
|
|
assert_eq!(addr.children.len(), 2);
|
|
assert_eq!(addr.children[0].name, "STREET");
|
|
assert_eq!(addr.children[1].name, "CITY");
|
|
}
|
|
|
|
#[test]
|
|
fn picture_clause_reassembled() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 WS-AMOUNT PIC S9(5)V99.\n",
|
|
);
|
|
assert_eq!(p.data[0].picture.as_deref(), Some("S9(5)V99"));
|
|
}
|
|
|
|
#[test]
|
|
fn picture_and_name_lowercase_normalized() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
01 ws-x pic x(4).\n",
|
|
);
|
|
assert_eq!(p.data[0].name, "WS-X");
|
|
assert_eq!(p.data[0].picture.as_deref(), Some("X(4)"));
|
|
}
|
|
|
|
#[test]
|
|
fn value_variants() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 WS-TEXT PIC X(5) VALUE 'BOB'.\n\
|
|
01 WS-ZERO PIC 9(3) VALUE ZERO.\n\
|
|
01 WS-NEG PIC S9(3) VALUE -5.\n",
|
|
);
|
|
assert_eq!(p.data[0].value.as_deref(), Some("'BOB'"));
|
|
assert_eq!(p.data[1].value.as_deref(), Some("ZERO"));
|
|
assert_eq!(p.data[2].value.as_deref(), Some("-5"));
|
|
}
|
|
|
|
#[test]
|
|
fn level_88_condition_names_nest() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 WS-STATUS PIC X.\n\
|
|
88 STATUS-OK VALUE 'O'.\n\
|
|
88 STATUS-BAD VALUE 'B'.\n",
|
|
);
|
|
let st = &p.data[0];
|
|
assert_eq!(st.name, "WS-STATUS");
|
|
assert_eq!(st.children.len(), 2);
|
|
assert_eq!(st.children[0].level, 88);
|
|
assert_eq!(st.children[0].name, "STATUS-OK");
|
|
assert_eq!(st.children[0].value.as_deref(), Some("'O'"));
|
|
assert_eq!(st.children[1].name, "STATUS-BAD");
|
|
}
|
|
|
|
#[test]
|
|
fn filler_data_items() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
01 HEADER-LINE.\n\
|
|
05 FILLER PIC X(10) VALUE 'NAME'.\n\
|
|
05 FILLER PIC X(10) VALUE 'AGE'.\n",
|
|
);
|
|
assert_eq!(p.data[0].children.len(), 2);
|
|
assert_eq!(p.data[0].children[0].name, "FILLER");
|
|
assert_eq!(p.data[0].children[1].name, "FILLER");
|
|
}
|
|
|
|
#[test]
|
|
fn select_and_fd_captured() {
|
|
let p = parse_src(
|
|
"ENVIRONMENT DIVISION.\n\
|
|
INPUT-OUTPUT SECTION.\n\
|
|
FILE-CONTROL.\n\
|
|
SELECT CLIENTES ASSIGN TO 'clientes.dat'.\n\
|
|
DATA DIVISION.\n\
|
|
FILE SECTION.\n\
|
|
FD CLIENTES.\n\
|
|
01 REG-CLIENTE PIC X(40).\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 WS-FIN PIC X.\n",
|
|
);
|
|
assert_eq!(p.files.len(), 1);
|
|
assert_eq!(p.files[0].name, "CLIENTES");
|
|
assert_eq!(p.files[0].path, "clientes.dat");
|
|
assert_eq!(p.files[0].record, "REG-CLIENTE");
|
|
}
|
|
|
|
#[test]
|
|
fn occurs_clause_captured() {
|
|
let p = parse_src(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 WS-TABLA.\n\
|
|
05 WS-ELEM PIC 9(3) OCCURS 10 TIMES.\n",
|
|
);
|
|
let elem = &p.data[0].children[0];
|
|
assert_eq!(elem.name, "WS-ELEM");
|
|
assert_eq!(elem.occurs, Some(10));
|
|
assert_eq!(elem.picture.as_deref(), Some("9(3)"));
|
|
}
|
|
|
|
#[test]
|
|
fn bad_level_number_is_error() {
|
|
let toks = lex(
|
|
"DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
99 WS-X PIC X.\n",
|
|
SourceFormat::Free,
|
|
)
|
|
.unwrap();
|
|
let err = parse(&toks).unwrap_err();
|
|
assert!(matches!(err, ParseError::BadLevel { found, .. } if found == "99"));
|
|
}
|
|
|
|
#[test]
|
|
fn procedure_paragraphs() {
|
|
let p = parse_src(
|
|
"PROCEDURE DIVISION.\n\
|
|
MAIN-PARA.\n\
|
|
DISPLAY 'HELLO'.\n\
|
|
PERFORM SUB-PARA.\n\
|
|
STOP RUN.\n\
|
|
SUB-PARA.\n\
|
|
DISPLAY 'SUB'.\n",
|
|
);
|
|
assert_eq!(p.paragraphs.len(), 2);
|
|
assert_eq!(p.paragraphs[0].name, "MAIN-PARA");
|
|
assert_eq!(p.paragraphs[0].sentences.len(), 3);
|
|
assert_eq!(p.paragraphs[1].name, "SUB-PARA");
|
|
assert_eq!(p.paragraphs[1].sentences.len(), 1);
|
|
// La sentencia conserva sus tokens crudos.
|
|
assert_eq!(p.paragraphs[0].sentences[0].tokens[0].text, "DISPLAY");
|
|
}
|
|
|
|
#[test]
|
|
fn implicit_paragraph_for_leading_statements() {
|
|
let p = parse_src(
|
|
"PROCEDURE DIVISION.\n\
|
|
DISPLAY 'FIRST'.\n\
|
|
MAIN-PARA.\n\
|
|
STOP RUN.\n",
|
|
);
|
|
assert_eq!(p.paragraphs.len(), 2);
|
|
assert_eq!(p.paragraphs[0].name, "");
|
|
assert_eq!(p.paragraphs[0].sentences.len(), 1);
|
|
assert_eq!(p.paragraphs[1].name, "MAIN-PARA");
|
|
assert_eq!(p.paragraphs[1].sentences.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn procedure_section_header_recognized() {
|
|
let p = parse_src(
|
|
"PROCEDURE DIVISION.\n\
|
|
INIT-SECTION SECTION.\n\
|
|
DISPLAY 'X'.\n",
|
|
);
|
|
assert_eq!(p.paragraphs.len(), 1);
|
|
assert_eq!(p.paragraphs[0].name, "INIT-SECTION");
|
|
assert_eq!(p.paragraphs[0].sentences.len(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn full_program_end_to_end() {
|
|
let p = parse_src(
|
|
"IDENTIFICATION DIVISION.\n\
|
|
PROGRAM-ID. ADDER.\n\
|
|
ENVIRONMENT DIVISION.\n\
|
|
DATA DIVISION.\n\
|
|
WORKING-STORAGE SECTION.\n\
|
|
01 WS-A PIC 9(3) VALUE 10.\n\
|
|
01 WS-B PIC 9(3) VALUE 32.\n\
|
|
01 WS-TOTAL PIC 9(4).\n\
|
|
PROCEDURE DIVISION.\n\
|
|
MAIN-PARA.\n\
|
|
ADD WS-A TO WS-B GIVING WS-TOTAL.\n\
|
|
DISPLAY WS-TOTAL.\n\
|
|
STOP RUN.\n",
|
|
);
|
|
assert_eq!(p.program_id.as_deref(), Some("ADDER"));
|
|
assert_eq!(p.data.len(), 3);
|
|
assert_eq!(p.data[0].value.as_deref(), Some("10"));
|
|
assert_eq!(p.data[2].name, "WS-TOTAL");
|
|
assert!(p.data[2].value.is_none());
|
|
assert_eq!(p.paragraphs.len(), 1);
|
|
assert_eq!(p.paragraphs[0].name, "MAIN-PARA");
|
|
assert_eq!(p.paragraphs[0].sentences.len(), 3);
|
|
}
|
|
}
|