charles/langrpg
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add: main function

Browse Source
This commit is contained in:
charles
2026-03-12 21:09:49 -07:00
parent c0951fc9d4
commit 90de2206db
9 changed files with 1062 additions and 671 deletions
Download Patch File Download Diff File Expand all files Collapse all files

771
src/main.rs
View File

@@ -1,701 +1,132 @@
//! rust-langrpg — RPG IV free-format parser
//! rust-langrpg — RPG IV compiler CLI
//!
//! Loads the BNF grammar embedded at compile time, builds a [`bnf::GrammarParser`],
//! and demonstrates parsing a handful of RPG IV free-format snippets.
//! Parses one or more RPG IV source files using the embedded BNF grammar
//! and optionally writes the resulting parse tree to an output file.
//!
//! ## Usage
//!
//! ```text
//! rust-langrpg [OPTIONS] <SOURCES>...
//!
//! Arguments:
//! <SOURCES>... RPG IV source file(s) to parse
//!
//! Options:
//! -o <OUTPUT> Write the parse tree to this file
//! -h, --help Print help
//! -V, --version Print version
//! ```
//!
//! ## Example
//!
//! ```text
//! cargo run --release -- -o out.txt hello.rpg
//! ```
use bnf::{Grammar, Term};
use std::{
fs,
io::{self, Write},
path::PathBuf,
process,
};
/// The RPG IV BNF grammar, embedded at compile time from `src/rpg.bnf`.
const RPG_BNF: &str = include_str!("rpg.bnf");
use clap::Parser;
use rust_langrpg::{load_grammar, parse_as};
// ─────────────────────────────────────────────────────────────────────────────
// Public API
// CLI definition
// ─────────────────────────────────────────────────────────────────────────────
/// Load and validate the RPG IV grammar.
///
/// Returns `Err` if the BNF source is malformed.
pub fn load_grammar() -> Result<Grammar, bnf::Error> {
RPG_BNF.parse::<Grammar>()
}
/// RPG IV free-format compiler — parses source files and emits parse trees.
#[derive(Parser, Debug)]
#[command(name = "rust-langrpg", version, about, long_about = None)]
struct Cli {
/// RPG IV source file(s) to parse.
#[arg(required = true, value_name = "SOURCES")]
sources: Vec<PathBuf>,
/// Parse `source` as the given `rule` (a non-terminal name such as `"statement"`).
///
/// Returns `Some(parse_tree_string)` for the first successful parse, or `None`
/// when the grammar cannot match the input.
pub fn parse_as<'a>(
parser: &'a bnf::GrammarParser,
source: &str,
rule: &str,
) -> Option<String> {
let target = Term::Nonterminal(rule.to_string());
parser
.parse_input_starting_with(source, &target)
.next()
.map(|tree| tree.to_string())
/// Write the parse tree(s) to this file.
/// If omitted the tree is not printed.
#[arg(short = 'o', value_name = "OUTPUT")]
output: Option<PathBuf>,
}
// ─────────────────────────────────────────────────────────────────────────────
// Demo helpers
// ─────────────────────────────────────────────────────────────────────────────
struct Example {
label: &'static str,
rule: &'static str,
src: &'static str,
}
fn run_example(parser: &bnf::GrammarParser, ex: &Example) {
println!(" ┌─ {} ({}) ─────────────────────", ex.label, ex.rule);
println!(" │ source : {:?}", ex.src);
match parse_as(parser, ex.src, ex.rule) {
Some(tree) => {
// Only print the first line of a potentially huge tree.
let preview: String = tree.lines().take(6).collect::<Vec<_>>().join("\n │ ");
println!(" │ result : OK");
println!(" │ tree : {}", preview);
}
None => println!(" │ result : NO PARSE"),
}
println!(" └──────────────────────────────────────────────");
println!();
}
// ─────────────────────────────────────────────────────────────────────────────
// main
// Entry point
// ─────────────────────────────────────────────────────────────────────────────
fn main() {
// ── 1. Load grammar ────────────────────────────────────────────────────
println!("=== RPG IV Free-Format Parser ===");
println!();
let cli = Cli::parse();
// ── Load grammar ─────────────────────────────────────────────────────────
let grammar = match load_grammar() {
Ok(g) => {
println!("[grammar] Loaded successfully.");
g
}
Ok(g) => g,
Err(e) => {
eprintln!("[grammar] Failed to parse BNF: {}", e);
std::process::exit(1);
eprintln!("error: failed to load RPG IV grammar: {e}");
process::exit(1);
}
};
// ── 2. Build parser ────────────────────────────────────────────────────
// ── Build parser ─────────────────────────────────────────────────────────
let parser = match grammar.build_parser() {
Ok(p) => {
println!("[parser] Built successfully (all non-terminals resolved).");
p
}
Ok(p) => p,
Err(e) => {
eprintln!("[parser] Failed to build: {}", e);
std::process::exit(1);
eprintln!("error: failed to build parser: {e}");
process::exit(1);
}
};
println!();
// ── 3. Example snippets ────────────────────────────────────────────────
//
// Each snippet is a *token stream* that matches the grammar rules.
// Because the `bnf` crate performs character-level / terminal matching
// the snippets are written exactly as the grammar expects them —
// individual keyword tokens separated by spaces aren't needed; the BNF
// uses quoted terminal strings so the parser works on the raw text.
//
// We showcase a range of rules from simple primitives all the way up to
// compound statements so you can see the grammar in action.
println!("=== Parsing Examples ===");
println!();
let examples: &[Example] = &[
// ── Identifiers ─────────────────────────────────────────────────────
Example {
label: "simple identifier",
rule: "identifier",
src: "myVar",
},
Example {
label: "identifier with digits and underscore",
rule: "identifier",
src: "calc_Total2",
},
// ── Literals ────────────────────────────────────────────────────────
Example {
label: "integer literal",
rule: "integer-literal",
src: "42",
},
Example {
label: "numeric literal (decimal)",
rule: "numeric-literal",
src: "3.14",
},
// ── Named constants ──────────────────────────────────────────────────
Example {
label: "named constant *ON",
rule: "named-constant",
src: "*ON",
},
Example {
label: "named constant *BLANKS",
rule: "named-constant",
src: "*BLANKS",
},
// ── Type specifications ──────────────────────────────────────────────
Example {
label: "CHAR type spec",
rule: "type-spec",
src: "CHAR(10)",
},
Example {
label: "PACKED type spec",
rule: "type-spec",
src: "PACKED(7:2)",
},
Example {
label: "INT type spec",
rule: "type-spec",
src: "INT(10)",
},
Example {
label: "DATE type spec",
rule: "type-spec",
src: "DATE",
},
Example {
label: "IND (indicator) type spec",
rule: "type-spec",
src: "IND",
},
// ── Declarations ─────────────────────────────────────────────────────
Example {
label: "standalone character variable",
rule: "standalone-decl",
src: "DCL-S myName CHAR(25);",
},
Example {
label: "standalone integer with initialiser",
rule: "standalone-decl",
src: "DCL-S counter INT(10) INZ(0);",
},
Example {
label: "constant declaration",
rule: "constant-decl",
src: "DCL-C MAX_SIZE CONST(100);",
},
// ── Control-option specification ─────────────────────────────────────
Example {
label: "CTL-OPT NOMAIN",
rule: "control-spec",
src: "CTL-OPT NOMAIN;",
},
Example {
label: "CTL-OPT DFTACTGRP(*NO)",
rule: "control-spec",
src: "CTL-OPT DFTACTGRP(*NO);",
},
// ── Statements ───────────────────────────────────────────────────────
Example {
label: "assignment statement",
rule: "assign-stmt",
src: "result=a+b;",
},
Example {
label: "EVAL assignment",
rule: "assign-stmt",
src: "EVAL result=42;",
},
Example {
label: "RETURN with value",
rule: "return-stmt",
src: "RETURN result;",
},
Example {
label: "bare RETURN",
rule: "return-stmt",
src: "RETURN;",
},
Example {
label: "LEAVE statement",
rule: "leave-stmt",
src: "LEAVE;",
},
Example {
label: "ITER statement",
rule: "iter-stmt",
src: "ITER;",
},
Example {
label: "EXSR call",
rule: "exsr-stmt",
src: "EXSR calcTotals;",
},
// ── I/O statements ───────────────────────────────────────────────────
Example {
label: "READ file",
rule: "read-stmt",
src: "READ myFile;",
},
Example {
label: "WRITE record",
rule: "write-stmt",
src: "WRITE outputRec;",
},
Example {
label: "CHAIN key into file",
rule: "chain-stmt",
src: "CHAIN keyFld myFile;",
},
Example {
label: "SETLL to beginning",
rule: "setll-stmt",
src: "SETLL *START myFile;",
},
Example {
label: "OPEN file",
rule: "open-stmt",
src: "OPEN myFile;",
},
Example {
label: "CLOSE file",
rule: "close-stmt",
src: "CLOSE myFile;",
},
Example {
label: "CLOSE *ALL",
rule: "close-stmt",
src: "CLOSE *ALL;",
},
// ── Expressions ──────────────────────────────────────────────────────
Example {
label: "simple addition expression",
rule: "expression",
src: "a+b",
},
Example {
label: "comparison expression",
rule: "expression",
src: "x>=10",
},
Example {
label: "NOT expression",
rule: "expression",
src: "NOT flag",
},
Example {
label: "combined AND / OR",
rule: "expression",
src: "a=1ANDb=2",
},
Example {
label: "parenthesised expression",
rule: "expression",
src: "(x+y)",
},
// ── Built-in functions ───────────────────────────────────────────────
Example {
label: "%LEN built-in",
rule: "built-in-function",
src: "%LEN(myField)",
},
Example {
label: "%TRIM built-in",
rule: "built-in-function",
src: "%TRIM(name)",
},
Example {
label: "%EOF built-in (no arg)",
rule: "built-in-function",
src: "%EOF()",
},
Example {
label: "%SUBST built-in (3-arg)",
rule: "built-in-function",
src: "%SUBST(str:1:5)",
},
Example {
label: "%DEC built-in",
rule: "built-in-function",
src: "%DEC(value:9:2)",
},
// ── Duration codes ───────────────────────────────────────────────────
Example {
label: "duration code *DAYS",
rule: "duration-code",
src: "*DAYS",
},
// ── Date / time formats ──────────────────────────────────────────────
Example {
label: "date format *ISO",
rule: "date-format",
src: "*ISO",
},
Example {
label: "time format *HMS",
rule: "time-format",
src: "*HMS",
},
// ── Qualified names ──────────────────────────────────────────────────
Example {
label: "simple qualified name",
rule: "qualified-name",
src: "myDs.field",
},
Example {
label: "deeply qualified name",
rule: "qualified-name",
src: "ds.subDs.leaf",
},
];
let total = examples.len();
let mut ok = 0usize;
let mut bad = 0usize;
for ex in examples {
let target = Term::Nonterminal(ex.rule.to_string());
let matched = parser
.parse_input_starting_with(ex.src, &target)
.next()
.is_some();
if matched {
ok += 1;
} else {
bad += 1;
// ── Open output sink ──────────────────────────────────────────────────────
// `output` is Box<dyn Write> so we can use either a file or a sink that
// discards everything when -o was not supplied.
let mut output: Box<dyn Write> = match &cli.output {
Some(path) => {
let file = fs::File::create(path).unwrap_or_else(|e| {
eprintln!("error: cannot open output file '{}': {e}", path.display());
process::exit(1);
});
Box::new(io::BufWriter::new(file))
}
None => Box::new(io::sink()),
};
run_example(&parser, ex);
// ── Process each source file ──────────────────────────────────────────────
let mut any_error = false;
for path in &cli.sources {
let source = match fs::read_to_string(path) {
Ok(s) => s,
Err(e) => {
eprintln!("error: cannot read '{}': {e}", path.display());
any_error = true;
continue;
}
};
// Try the top-level "program" rule first; fall back to "source-file"
// so the binary is useful even if only one of those rule names exists
// in the grammar.
let tree = parse_as(&parser, source.trim(), "program")
.or_else(|| parse_as(&parser, source.trim(), "source-file"));
match tree {
Some(t) => {
eprintln!("ok: {}", path.display());
writeln!(output, "=== {} ===", path.display())
.and_then(|_| writeln!(output, "{t}"))
.unwrap_or_else(|e| {
eprintln!("error: write failed: {e}");
any_error = true;
});
}
None => {
eprintln!("error: '{}' did not match the RPG IV grammar", path.display());
any_error = true;
}
}
}
// ── 4. Summary ─────────────────────────────────────────────────────────
println!("=== Summary ===");
println!(" total : {}", total);
println!(" matched : {}", ok);
println!(" failed : {}", bad);
println!();
if bad == 0 {
println!("All examples parsed successfully.");
} else {
println!("{} example(s) did not parse — check the BNF or the snippet.", bad);
std::process::exit(1);
}
}
// ─────────────────────────────────────────────────────────────────────────────
// Unit tests
// ─────────────────────────────────────────────────────────────────────────────
#[cfg(test)]
mod tests {
use super::*;
/// Leak a `Grammar` onto the heap so the returned `GrammarParser` can hold
/// a `'static` reference to it. The tiny allocation is intentional: this
/// is test-only code and the process exits shortly after.
fn make_parser() -> bnf::GrammarParser<'static> {
let grammar: &'static bnf::Grammar =
Box::leak(Box::new(load_grammar().expect("BNF must be valid")));
grammar
.build_parser()
.expect("all non-terminals must resolve")
}
// ── Grammar loading ──────────────────────────────────────────────────────
#[test]
fn grammar_loads() {
load_grammar().expect("grammar should parse without error");
}
#[test]
fn parser_builds() {
make_parser();
}
// ── Identifiers ──────────────────────────────────────────────────────────
#[test]
fn identifier_simple() {
let p = make_parser();
assert!(parse_as(&p, "abc", "identifier").is_some());
}
#[test]
fn identifier_with_underscore() {
let p = make_parser();
assert!(parse_as(&p, "my_var", "identifier").is_some());
}
#[test]
fn identifier_single_letter() {
let p = make_parser();
assert!(parse_as(&p, "x", "identifier").is_some());
}
// ── Literals ─────────────────────────────────────────────────────────────
#[test]
fn integer_literal() {
let p = make_parser();
assert!(parse_as(&p, "0", "integer-literal").is_some());
assert!(parse_as(&p, "999", "integer-literal").is_some());
}
#[test]
fn numeric_literal_decimal() {
let p = make_parser();
assert!(parse_as(&p, "3.14", "numeric-literal").is_some());
}
// ── Named constants ───────────────────────────────────────────────────────
#[test]
fn named_constants() {
let p = make_parser();
for s in &["*ON", "*OFF", "*BLANK", "*BLANKS", "*ZEROS", "*ZERO",
"*HIVAL", "*LOVAL", "*NULL"] {
assert!(parse_as(&p, s, "named-constant").is_some(), "{} failed", s);
}
}
// ── Type specs ────────────────────────────────────────────────────────────
#[test]
fn type_spec_char() {
let p = make_parser();
assert!(parse_as(&p, "CHAR(50)", "type-spec").is_some());
}
#[test]
fn type_spec_packed() {
let p = make_parser();
assert!(parse_as(&p, "PACKED(9:2)", "type-spec").is_some());
}
#[test]
fn type_spec_date() {
let p = make_parser();
assert!(parse_as(&p, "DATE", "type-spec").is_some());
}
#[test]
fn type_spec_ind() {
let p = make_parser();
assert!(parse_as(&p, "IND", "type-spec").is_some());
}
#[test]
fn type_spec_pointer() {
let p = make_parser();
assert!(parse_as(&p, "POINTER", "type-spec").is_some());
}
// ── Declarations ─────────────────────────────────────────────────────────
#[test]
fn standalone_decl_no_inz() {
let p = make_parser();
assert!(parse_as(&p, "DCL-S total PACKED(9:2);", "standalone-decl").is_some());
}
#[test]
fn standalone_decl_with_inz() {
let p = make_parser();
assert!(parse_as(&p, "DCL-S counter INT(10) INZ(0);", "standalone-decl").is_some());
}
#[test]
fn constant_decl() {
let p = make_parser();
assert!(parse_as(&p, "DCL-C MAX CONST(100);", "constant-decl").is_some());
}
// ── Control spec ──────────────────────────────────────────────────────────
#[test]
fn ctl_opt_nomain() {
let p = make_parser();
assert!(parse_as(&p, "CTL-OPT NOMAIN;", "control-spec").is_some());
}
#[test]
fn ctl_opt_dftactgrp_no() {
let p = make_parser();
assert!(parse_as(&p, "CTL-OPT DFTACTGRP(*NO);", "control-spec").is_some());
}
// ── Statements ───────────────────────────────────────────────────────────
#[test]
fn assign_simple() {
let p = make_parser();
assert!(parse_as(&p, "x=1;", "assign-stmt").is_some());
}
#[test]
fn return_with_expr() {
let p = make_parser();
assert!(parse_as(&p, "RETURN result;", "return-stmt").is_some());
}
#[test]
fn return_bare() {
let p = make_parser();
assert!(parse_as(&p, "RETURN;", "return-stmt").is_some());
}
#[test]
fn leave_stmt() {
let p = make_parser();
assert!(parse_as(&p, "LEAVE;", "leave-stmt").is_some());
}
#[test]
fn iter_stmt() {
let p = make_parser();
assert!(parse_as(&p, "ITER;", "iter-stmt").is_some());
}
#[test]
fn exsr_stmt() {
let p = make_parser();
assert!(parse_as(&p, "EXSR myRoutine;", "exsr-stmt").is_some());
}
#[test]
fn read_stmt() {
let p = make_parser();
assert!(parse_as(&p, "READ myFile;", "read-stmt").is_some());
}
#[test]
fn write_stmt() {
let p = make_parser();
assert!(parse_as(&p, "WRITE outRec;", "write-stmt").is_some());
}
#[test]
fn chain_stmt() {
let p = make_parser();
assert!(parse_as(&p, "CHAIN key myFile;", "chain-stmt").is_some());
}
#[test]
fn setll_start() {
let p = make_parser();
assert!(parse_as(&p, "SETLL *START myFile;", "setll-stmt").is_some());
}
#[test]
fn open_close() {
let p = make_parser();
assert!(parse_as(&p, "OPEN myFile;", "open-stmt").is_some());
assert!(parse_as(&p, "CLOSE myFile;", "close-stmt").is_some());
}
#[test]
fn close_all() {
let p = make_parser();
assert!(parse_as(&p, "CLOSE *ALL;", "close-stmt").is_some());
}
// ── Expressions ──────────────────────────────────────────────────────────
#[test]
fn expression_addition() {
let p = make_parser();
assert!(parse_as(&p, "a+b", "expression").is_some());
}
#[test]
fn expression_comparison() {
let p = make_parser();
assert!(parse_as(&p, "x=1", "expression").is_some());
assert!(parse_as(&p, "x<>0", "expression").is_some());
}
#[test]
fn expression_not() {
let p = make_parser();
assert!(parse_as(&p, "NOT flag", "expression").is_some());
}
#[test]
fn expression_parenthesised() {
let p = make_parser();
assert!(parse_as(&p, "(x+1)", "expression").is_some());
}
// ── Built-in functions ───────────────────────────────────────────────────
#[test]
fn builtin_len() {
let p = make_parser();
assert!(parse_as(&p, "%LEN(myField)", "built-in-function").is_some());
}
#[test]
fn builtin_trim() {
let p = make_parser();
assert!(parse_as(&p, "%TRIM(s)", "built-in-function").is_some());
}
#[test]
fn builtin_eof_no_arg() {
let p = make_parser();
assert!(parse_as(&p, "%EOF()", "built-in-function").is_some());
}
#[test]
fn builtin_subst_3arg() {
let p = make_parser();
assert!(parse_as(&p, "%SUBST(s:1:5)", "built-in-function").is_some());
}
// ── Date / time formats ──────────────────────────────────────────────────
#[test]
fn date_formats() {
let p = make_parser();
for fmt in &["*MDY", "*DMY", "*YMD", "*JUL", "*ISO", "*USA", "*EUR", "*JIS"] {
assert!(parse_as(&p, fmt, "date-format").is_some(), "{} failed", fmt);
}
}
#[test]
fn time_formats() {
let p = make_parser();
for fmt in &["*HMS", "*ISO", "*USA", "*EUR", "*JIS"] {
assert!(parse_as(&p, fmt, "time-format").is_some(), "{} failed", fmt);
}
}
// ── Qualified names ───────────────────────────────────────────────────────
#[test]
fn qualified_name_simple() {
let p = make_parser();
assert!(parse_as(&p, "myVar", "qualified-name").is_some());
}
#[test]
fn qualified_name_dotted() {
let p = make_parser();
assert!(parse_as(&p, "ds.field", "qualified-name").is_some());
}
// ── Duration codes ───────────────────────────────────────────────────────
#[test]
fn duration_codes() {
let p = make_parser();
for code in &["*YEARS", "*MONTHS", "*DAYS", "*HOURS", "*MINUTES",
"*SECONDS", "*MSECONDS"] {
assert!(parse_as(&p, code, "duration-code").is_some(), "{} failed", code);
}
if any_error {
process::exit(1);
}
}