sergio
634a43006a
El formateo de informes de COBOL: supresión de ceros a la izquierda, coma de millares e inserción del punto decimal. Rebanada vertical. - charka-lexer: el punto separador exige un espacio detrás; un punto pegado a un carácter (ZZ9.99) ya no es terminador, sino símbolo — el parser lo reensambla dentro de la cláusula PICTURE. - charka-runtime: format_edited(valor, pic) — 9, Z, coma, punto, B. - charka-ir: Field::edit guarda la PICTURE; el campo es texto. - charka-codegen / charka-shadow: MOVE a un campo de edición pasa por format_edited antes de almacenar. - Corpus: 19-reporte. Sombra y crate compilado dan la misma salida. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
488 lines
16 KiB
Rust
488 lines
16 KiB
Rust
//! `charka-lexer` — tokenizador de COBOL.
|
|
//!
|
|
//! Primera etapa del transpilador COBOL→Rust: convierte el texto fuente
|
|
//! en una secuencia de [`Token`]. El lexer es **deliberadamente tonto**
|
|
//! — no conoce keywords ni la cláusula `PICTURE`; emite `Word` para todo
|
|
//! identificador y deja la clasificación al parser. COBOL es
|
|
//! case-insensitive: el `text` de un `Word` va en su caja original y
|
|
//! quien matchee keywords debe normalizar.
|
|
//!
|
|
//! Soporta los dos formatos de fuente:
|
|
//! - **Fijo** (`SourceFormat::Fixed`) — la tarjeta de 80 columnas:
|
|
//! cols 1-6 área de secuencia, col 7 indicadora (`*`/`/` comentario,
|
|
//! `D` debugging), cols 8-72 código, 73-80 identificación.
|
|
//! - **Libre** (`SourceFormat::Free`) — la línea entera es código; `*`
|
|
//! o `*>` al inicio (tras espacios) es comentario.
|
|
//!
|
|
//! Limitación conocida (v1): no soporta continuación de literales entre
|
|
//! líneas (indicador `-` en col 7) — esos casos se tratan como código
|
|
//! normal. Es un subconjunto COBOL'85; el hito intermedio del plan.
|
|
|
|
#![forbid(unsafe_code)]
|
|
|
|
use thiserror::Error;
|
|
|
|
/// Formato del código fuente COBOL.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum SourceFormat {
|
|
/// Formato fijo tradicional (tarjeta de 80 columnas).
|
|
Fixed,
|
|
/// Formato libre: la línea entera es código.
|
|
Free,
|
|
}
|
|
|
|
/// Clase de un token.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum TokenKind {
|
|
/// Palabra COBOL: keyword o identificador (puede llevar guiones
|
|
/// internos, p. ej. `WORKING-STORAGE`).
|
|
Word,
|
|
/// Literal numérico sin signo (`42`, `3.14`). El signo, si lo hay,
|
|
/// es un `Symbol` aparte.
|
|
Number,
|
|
/// Literal de texto, con las comillas dobladas ya colapsadas.
|
|
String,
|
|
/// El punto `.` — terminador de sentencia/párrafo en COBOL.
|
|
Period,
|
|
/// Cualquier otro símbolo: `( ) , ; :` y los operadores
|
|
/// `+ - * / ** = < > <= >= <>`. El símbolo concreto va en `text`.
|
|
Symbol,
|
|
}
|
|
|
|
/// Un token con su posición en el fuente (línea y columna 1-based).
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Token {
|
|
pub kind: TokenKind,
|
|
/// Lexema. `Word`: caja original. `String`: valor ya decodificado.
|
|
/// `Number`/`Symbol`/`Period`: los caracteres tal cual.
|
|
pub text: String,
|
|
/// Línea 1-based.
|
|
pub line: u32,
|
|
/// Columna 1-based del primer carácter del token.
|
|
pub col: u32,
|
|
}
|
|
|
|
/// Error de tokenización, con la posición donde ocurrió.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Error)]
|
|
pub enum LexError {
|
|
#[error("línea {line}:{col}: literal de texto sin cerrar")]
|
|
UnterminatedString { line: u32, col: u32 },
|
|
#[error("línea {line}:{col}: carácter inesperado {ch:?}")]
|
|
UnexpectedChar { line: u32, col: u32, ch: char },
|
|
}
|
|
|
|
/// Tokeniza un fuente COBOL completo. Falla con el primer [`LexError`].
|
|
pub fn lex(source: &str, format: SourceFormat) -> Result<Vec<Token>, LexError> {
|
|
let mut tokens = Vec::new();
|
|
for (idx, raw) in source.lines().enumerate() {
|
|
let line = (idx + 1) as u32;
|
|
if let Some((content, base_col)) = prepare_line(raw, format) {
|
|
lex_line(&content, line, base_col, &mut tokens)?;
|
|
}
|
|
}
|
|
Ok(tokens)
|
|
}
|
|
|
|
/// Extrae el área de código de una línea según el formato. `None` si la
|
|
/// línea entera se descarta (comentario, debugging). El `u32` es la
|
|
/// columna 1-based del primer carácter del contenido devuelto.
|
|
fn prepare_line(raw: &str, format: SourceFormat) -> Option<(String, u32)> {
|
|
match format {
|
|
SourceFormat::Fixed => {
|
|
let chars: Vec<char> = raw.chars().collect();
|
|
// Col 7 (índice 6): área indicadora.
|
|
match chars.get(6).copied().unwrap_or(' ') {
|
|
'*' | '/' => return None, // comentario / salto de página
|
|
'D' | 'd' => return None, // línea de debugging — v1 la omite
|
|
_ => {}
|
|
}
|
|
// Cols 8-72 (índices 7..72) = 65 columnas de código.
|
|
let content: String = chars.iter().skip(7).take(65).collect();
|
|
Some((content, 8))
|
|
}
|
|
SourceFormat::Free => {
|
|
let trimmed = raw.trim_start();
|
|
if trimmed.starts_with('*') {
|
|
return None; // `*` o `*>` al inicio: comentario
|
|
}
|
|
Some((raw.to_string(), 1))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Tokeniza una línea ya recortada al área de código.
|
|
fn lex_line(content: &str, line: u32, base_col: u32, out: &mut Vec<Token>) -> Result<(), LexError> {
|
|
let chars: Vec<char> = content.chars().collect();
|
|
let mut i = 0;
|
|
while i < chars.len() {
|
|
let c = chars[i];
|
|
let col = base_col + i as u32;
|
|
if c.is_whitespace() {
|
|
i += 1;
|
|
continue;
|
|
}
|
|
if c == '\'' || c == '"' {
|
|
let (value, next) = lex_string(&chars, i, c, line, col)?;
|
|
out.push(Token {
|
|
kind: TokenKind::String,
|
|
text: value,
|
|
line,
|
|
col,
|
|
});
|
|
i = next;
|
|
} else if c.is_ascii_digit() {
|
|
let (text, next) = lex_number(&chars, i);
|
|
out.push(Token {
|
|
kind: TokenKind::Number,
|
|
text,
|
|
line,
|
|
col,
|
|
});
|
|
i = next;
|
|
} else if c.is_ascii_alphabetic() {
|
|
let (text, next) = lex_word(&chars, i);
|
|
out.push(Token {
|
|
kind: TokenKind::Word,
|
|
text,
|
|
line,
|
|
col,
|
|
});
|
|
i = next;
|
|
} else if c == '.' {
|
|
// El separador de sentencia COBOL siempre lleva un espacio
|
|
// (o el fin de línea) detrás. Un punto pegado a un carácter
|
|
// —`ZZ9.99`— no es separador: pertenece a una PICTURE de
|
|
// edición y se emite como símbolo para que el parser lo
|
|
// reensamble dentro de la cláusula.
|
|
let is_separator = chars
|
|
.get(i + 1)
|
|
.map_or(true, |n| n.is_whitespace());
|
|
out.push(Token {
|
|
kind: if is_separator {
|
|
TokenKind::Period
|
|
} else {
|
|
TokenKind::Symbol
|
|
},
|
|
text: ".".into(),
|
|
line,
|
|
col,
|
|
});
|
|
i += 1;
|
|
} else if let Some(op) = two_char_op(&chars, i) {
|
|
out.push(Token {
|
|
kind: TokenKind::Symbol,
|
|
text: op.into(),
|
|
line,
|
|
col,
|
|
});
|
|
i += 2;
|
|
} else if "()+-*/=<>,;:".contains(c) {
|
|
out.push(Token {
|
|
kind: TokenKind::Symbol,
|
|
text: c.to_string(),
|
|
line,
|
|
col,
|
|
});
|
|
i += 1;
|
|
} else {
|
|
return Err(LexError::UnexpectedChar { line, col, ch: c });
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Lee un literal de texto desde la comilla de apertura. Una comilla
|
|
/// doblada dentro del literal representa una comilla literal.
|
|
fn lex_string(
|
|
chars: &[char],
|
|
start: usize,
|
|
quote: char,
|
|
line: u32,
|
|
col: u32,
|
|
) -> Result<(String, usize), LexError> {
|
|
let mut value = String::new();
|
|
let mut i = start + 1;
|
|
while i < chars.len() {
|
|
if chars[i] == quote {
|
|
if chars.get(i + 1) == Some("e) {
|
|
value.push(quote); // comilla doblada → comilla literal
|
|
i += 2;
|
|
} else {
|
|
return Ok((value, i + 1)); // comilla de cierre
|
|
}
|
|
} else {
|
|
value.push(chars[i]);
|
|
i += 1;
|
|
}
|
|
}
|
|
Err(LexError::UnterminatedString { line, col })
|
|
}
|
|
|
|
/// Lee un literal numérico sin signo. El punto decimal sólo cuenta si
|
|
/// lo sigue un dígito — sino es el terminador `.`.
|
|
fn lex_number(chars: &[char], start: usize) -> (String, usize) {
|
|
let mut i = start;
|
|
while i < chars.len() && chars[i].is_ascii_digit() {
|
|
i += 1;
|
|
}
|
|
if i + 1 < chars.len() && chars[i] == '.' && chars[i + 1].is_ascii_digit() {
|
|
i += 1;
|
|
while i < chars.len() && chars[i].is_ascii_digit() {
|
|
i += 1;
|
|
}
|
|
}
|
|
(chars[start..i].iter().collect(), i)
|
|
}
|
|
|
|
/// Lee una palabra COBOL: empieza con letra, sigue con alfanuméricos y
|
|
/// guiones internos (un guión sólo si lo sigue un alfanumérico).
|
|
fn lex_word(chars: &[char], start: usize) -> (String, usize) {
|
|
let mut i = start + 1;
|
|
while i < chars.len() {
|
|
let c = chars[i];
|
|
// Alfanumérico, o un guión interno (sólo si lo sigue otro
|
|
// alfanumérico — `WORKING-STORAGE`, no un `MOVE-` colgante).
|
|
let word_char = c.is_ascii_alphanumeric()
|
|
|| (c == '-' && chars.get(i + 1).is_some_and(|n| n.is_ascii_alphanumeric()));
|
|
if !word_char {
|
|
break;
|
|
}
|
|
i += 1;
|
|
}
|
|
(chars[start..i].iter().collect(), i)
|
|
}
|
|
|
|
/// Reconoce un operador de dos caracteres en la posición `i`.
|
|
fn two_char_op(chars: &[char], i: usize) -> Option<&'static str> {
|
|
let a = *chars.get(i)?;
|
|
let b = *chars.get(i + 1)?;
|
|
match (a, b) {
|
|
('*', '*') => Some("**"),
|
|
('<', '=') => Some("<="),
|
|
('>', '=') => Some(">="),
|
|
('<', '>') => Some("<>"),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
/// Helper: lexa y devuelve `(kind, text)` por token.
|
|
fn kinds(src: &str, fmt: SourceFormat) -> Vec<(TokenKind, String)> {
|
|
lex(src, fmt)
|
|
.expect("lex OK")
|
|
.into_iter()
|
|
.map(|t| (t.kind, t.text))
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn simple_sentence_free() {
|
|
let toks = kinds("MOVE 5 TO WS-COUNT.", SourceFormat::Free);
|
|
assert_eq!(
|
|
toks,
|
|
vec![
|
|
(TokenKind::Word, "MOVE".into()),
|
|
(TokenKind::Number, "5".into()),
|
|
(TokenKind::Word, "TO".into()),
|
|
(TokenKind::Word, "WS-COUNT".into()),
|
|
(TokenKind::Period, ".".into()),
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn hyphenated_word_kept_whole() {
|
|
let toks = kinds("WORKING-STORAGE SECTION.", SourceFormat::Free);
|
|
assert_eq!(toks[0], (TokenKind::Word, "WORKING-STORAGE".into()));
|
|
assert_eq!(toks[1], (TokenKind::Word, "SECTION".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn word_case_is_preserved() {
|
|
let toks = kinds("Move x", SourceFormat::Free);
|
|
assert_eq!(toks[0].1, "Move");
|
|
assert_eq!(toks[1].1, "x");
|
|
}
|
|
|
|
#[test]
|
|
fn string_literal_value_decoded() {
|
|
let toks = kinds("'hola mundo'", SourceFormat::Free);
|
|
assert_eq!(toks, vec![(TokenKind::String, "hola mundo".into())]);
|
|
}
|
|
|
|
#[test]
|
|
fn doubled_quote_is_literal_quote() {
|
|
let toks = kinds("'it''s ok'", SourceFormat::Free);
|
|
assert_eq!(toks, vec![(TokenKind::String, "it's ok".into())]);
|
|
}
|
|
|
|
#[test]
|
|
fn double_quoted_string() {
|
|
let toks = kinds("\"abc\"", SourceFormat::Free);
|
|
assert_eq!(toks, vec![(TokenKind::String, "abc".into())]);
|
|
}
|
|
|
|
#[test]
|
|
fn number_with_decimal_vs_trailing_period() {
|
|
// `3.14` es un número; `5.` es número 5 + terminador.
|
|
assert_eq!(
|
|
kinds("3.14", SourceFormat::Free),
|
|
vec![(TokenKind::Number, "3.14".into())]
|
|
);
|
|
assert_eq!(
|
|
kinds("5.", SourceFormat::Free),
|
|
vec![
|
|
(TokenKind::Number, "5".into()),
|
|
(TokenKind::Period, ".".into()),
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn period_inside_an_edit_picture_is_not_a_separator() {
|
|
// El punto de `ZZ9.99` va pegado a un dígito: es símbolo, no
|
|
// terminador. El punto final, con espacio detrás, sí termina.
|
|
let toks = kinds("PIC Z,ZZ9.99 .", SourceFormat::Free);
|
|
let dots: Vec<TokenKind> = toks
|
|
.iter()
|
|
.filter(|(_, t)| t == ".")
|
|
.map(|(k, _)| *k)
|
|
.collect();
|
|
assert_eq!(dots, vec![TokenKind::Symbol, TokenKind::Period]);
|
|
}
|
|
|
|
#[test]
|
|
fn two_and_one_char_operators() {
|
|
let toks = kinds("A <= B >= C <> D ** E + F", SourceFormat::Free);
|
|
let syms: Vec<&str> = toks
|
|
.iter()
|
|
.filter(|(k, _)| *k == TokenKind::Symbol)
|
|
.map(|(_, t)| t.as_str())
|
|
.collect();
|
|
assert_eq!(syms, vec!["<=", ">=", "<>", "**", "+"]);
|
|
}
|
|
|
|
#[test]
|
|
fn parens_and_separators() {
|
|
let toks = kinds("PIC X(20), Y;", SourceFormat::Free);
|
|
let syms: Vec<&str> = toks
|
|
.iter()
|
|
.filter(|(k, _)| *k == TokenKind::Symbol)
|
|
.map(|(_, t)| t.as_str())
|
|
.collect();
|
|
assert_eq!(syms, vec!["(", ")", ",", ";"]);
|
|
}
|
|
|
|
#[test]
|
|
fn fixed_format_ignores_sequence_and_id_areas() {
|
|
// Cols 1-6 secuencia, col 7 espacio, cols 8.. código, 73+ id.
|
|
let mut line = String::new();
|
|
line.push_str("000100"); // cols 1-6: secuencia
|
|
line.push(' '); // col 7: indicador
|
|
line.push_str(" MOVE 1 TO X."); // código desde col 8
|
|
// Rellenar hasta col 73 y agregar área de identificación.
|
|
while line.chars().count() < 72 {
|
|
line.push(' ');
|
|
}
|
|
line.push_str("PROG0001"); // cols 73-80: ignoradas
|
|
let toks = kinds(&line, SourceFormat::Fixed);
|
|
assert_eq!(
|
|
toks,
|
|
vec![
|
|
(TokenKind::Word, "MOVE".into()),
|
|
(TokenKind::Number, "1".into()),
|
|
(TokenKind::Word, "TO".into()),
|
|
(TokenKind::Word, "X".into()),
|
|
(TokenKind::Period, ".".into()),
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn fixed_format_comment_line_skipped() {
|
|
let comment = "000100* esto es un comentario y no debe tokenizar";
|
|
let code = "000200 DISPLAY 'HI'.";
|
|
let src = format!("{comment}\n{code}");
|
|
let toks = kinds(&src, SourceFormat::Fixed);
|
|
assert_eq!(
|
|
toks,
|
|
vec![
|
|
(TokenKind::Word, "DISPLAY".into()),
|
|
(TokenKind::String, "HI".into()),
|
|
(TokenKind::Period, ".".into()),
|
|
]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn free_format_comment_line_skipped() {
|
|
let src = "* un comentario\n*> otro comentario\nDISPLAY 1.";
|
|
let toks = kinds(src, SourceFormat::Free);
|
|
assert_eq!(toks.len(), 3); // DISPLAY 1 .
|
|
assert_eq!(toks[0], (TokenKind::Word, "DISPLAY".into()));
|
|
}
|
|
|
|
#[test]
|
|
fn line_and_column_are_tracked() {
|
|
let src = "MOVE 1\n TO X.";
|
|
let toks = lex(src, SourceFormat::Free).unwrap();
|
|
assert_eq!((toks[0].line, toks[0].col), (1, 1)); // MOVE
|
|
assert_eq!((toks[1].line, toks[1].col), (1, 6)); // 1
|
|
assert_eq!((toks[2].line, toks[2].col), (2, 3)); // TO
|
|
assert_eq!((toks[3].line, toks[3].col), (2, 6)); // X
|
|
}
|
|
|
|
#[test]
|
|
fn unterminated_string_is_an_error() {
|
|
let err = lex("MOVE 'sin cerrar", SourceFormat::Free).unwrap_err();
|
|
assert!(matches!(err, LexError::UnterminatedString { line: 1, .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn unexpected_char_is_an_error() {
|
|
let err = lex("MOVE 5 ! X", SourceFormat::Free).unwrap_err();
|
|
assert!(matches!(
|
|
err,
|
|
LexError::UnexpectedChar {
|
|
ch: '!',
|
|
line: 1,
|
|
..
|
|
}
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn empty_source_yields_no_tokens() {
|
|
assert!(lex("", SourceFormat::Free).unwrap().is_empty());
|
|
assert!(lex("\n\n \n", SourceFormat::Free).unwrap().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn realistic_paragraph() {
|
|
let src = "\
|
|
ADD-TOTALS.
|
|
COMPUTE WS-TOTAL = WS-A + WS-B.
|
|
IF WS-TOTAL > 100
|
|
DISPLAY 'GRANDE'
|
|
END-IF.";
|
|
let toks = lex(src, SourceFormat::Free).unwrap();
|
|
// Arranca con el nombre del párrafo y su punto.
|
|
assert_eq!(toks[0].text, "ADD-TOTALS");
|
|
assert_eq!(toks[1].kind, TokenKind::Period);
|
|
// Hay un literal y el operador `>` y `=` en el medio.
|
|
assert!(toks
|
|
.iter()
|
|
.any(|t| t.kind == TokenKind::String && t.text == "GRANDE"));
|
|
assert!(toks
|
|
.iter()
|
|
.any(|t| t.kind == TokenKind::Symbol && t.text == ">"));
|
|
assert!(toks
|
|
.iter()
|
|
.any(|t| t.kind == TokenKind::Symbol && t.text == "="));
|
|
assert!(toks.iter().any(|t| t.text == "END-IF"));
|
|
}
|
|
}
|