jit: ops_ext delegation + M3 syntax scaffolding; unify BoxCall execution path
This commit is contained in:
Moe Charm
262
build.rs
Normal file
262
build.rs
Normal file
@ -0,0 +1,262 @@
|
||||
use std::{env, fs, path::PathBuf};
|
||||
|
||||
fn main() {
|
||||
// Path to grammar spec
|
||||
let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
|
||||
let grammar_dir = manifest_dir.join("grammar");
|
||||
let grammar_file = grammar_dir.join("unified-grammar.toml");
|
||||
|
||||
// Ensure output dir exists
|
||||
let out_dir = manifest_dir.join("src").join("grammar");
|
||||
fs::create_dir_all(&out_dir).ok();
|
||||
let out_file = out_dir.join("generated.rs");
|
||||
|
||||
// If grammar file is missing, create a minimal one
|
||||
if !grammar_file.exists() {
|
||||
fs::create_dir_all(&grammar_dir).ok();
|
||||
let minimal = r#"
|
||||
[keywords.me]
|
||||
token = "ME"
|
||||
|
||||
[keywords.from]
|
||||
token = "FROM"
|
||||
|
||||
[keywords.loop]
|
||||
token = "LOOP"
|
||||
|
||||
[operators.add]
|
||||
symbol = "+"
|
||||
coercion_strategy = "string_priority"
|
||||
type_rules = [
|
||||
{ left = "String", right = "String", result = "String", action = "concat" },
|
||||
{ left = "String", right = "Integer", result = "String", action = "concat" },
|
||||
{ left = "Integer", right = "String", result = "String", action = "concat" },
|
||||
{ left = "String", right = "Bool", result = "String", action = "concat" },
|
||||
{ left = "Bool", right = "String", result = "String", action = "concat" },
|
||||
{ left = "String", right = "Other", result = "String", action = "concat" },
|
||||
{ left = "Other", right = "String", result = "String", action = "concat" },
|
||||
{ left = "Integer", right = "Integer", result = "Integer", action = "add_i64" },
|
||||
{ left = "Float", right = "Float", result = "Float", action = "add_f64" }
|
||||
]
|
||||
"#;
|
||||
fs::write(&grammar_file, minimal).expect("write minimal unified-grammar.toml");
|
||||
println!("cargo:warning=Created minimal grammar at {}", grammar_file.display());
|
||||
}
|
||||
|
||||
// Read and very light parse: collect
|
||||
// - keywords.<name>.token
|
||||
// - operators.{add,sub,mul,div}.{coercion_strategy,type_rules}
|
||||
// - syntax.statements.allow = [..]
|
||||
// - syntax.expressions.allow_binops = [..]
|
||||
let content = fs::read_to_string(&grammar_file).expect("read unified-grammar.toml");
|
||||
|
||||
// Naive line scan to avoid build-deps; supports lines like: [keywords.xxx] then token = "YYY"
|
||||
let mut current_key: Option<String> = None;
|
||||
let mut in_operators_add = false;
|
||||
let mut in_operators_sub = false;
|
||||
let mut in_operators_mul = false;
|
||||
let mut in_operators_div = false;
|
||||
let mut add_coercion: Option<String> = None;
|
||||
let mut sub_coercion: Option<String> = None;
|
||||
let mut mul_coercion: Option<String> = None;
|
||||
let mut div_coercion: Option<String> = None;
|
||||
let mut entries: Vec<(String, String)> = Vec::new();
|
||||
let mut in_type_rules = false;
|
||||
let mut add_rules: Vec<(String, String, String, String)> = Vec::new();
|
||||
let mut sub_rules: Vec<(String, String, String, String)> = Vec::new();
|
||||
let mut mul_rules: Vec<(String, String, String, String)> = Vec::new();
|
||||
let mut div_rules: Vec<(String, String, String, String)> = Vec::new();
|
||||
for line in content.lines() {
|
||||
let s = line.trim();
|
||||
if s.starts_with("[keywords.") && s.ends_with("]") {
|
||||
let name = s.trim_start_matches("[keywords.").trim_end_matches("]").to_string();
|
||||
current_key = Some(name);
|
||||
in_operators_add = false;
|
||||
in_operators_sub = false;
|
||||
in_operators_mul = false;
|
||||
in_operators_div = false;
|
||||
continue;
|
||||
}
|
||||
if s == "[operators.add]" { current_key = None; in_operators_add = true; in_operators_sub=false; in_operators_mul=false; in_operators_div=false; in_type_rules = false; continue; }
|
||||
if s == "[operators.sub]" { current_key = None; in_operators_add = false; in_operators_sub=true; in_operators_mul=false; in_operators_div=false; in_type_rules = false; continue; }
|
||||
if s == "[operators.mul]" { current_key = None; in_operators_add = false; in_operators_sub=false; in_operators_mul=true; in_operators_div=false; in_type_rules = false; continue; }
|
||||
if s == "[operators.div]" { current_key = None; in_operators_add = false; in_operators_sub=false; in_operators_mul=false; in_operators_div=true; in_type_rules = false; continue; }
|
||||
if let Some(ref key) = current_key {
|
||||
if let Some(rest) = s.strip_prefix("token") {
|
||||
if let Some(eq) = rest.find('=') {
|
||||
let val = rest[eq+1..].trim().trim_matches('"').to_string();
|
||||
entries.push((key.clone(), val));
|
||||
}
|
||||
}
|
||||
}
|
||||
if in_operators_add || in_operators_sub || in_operators_mul || in_operators_div {
|
||||
if s.starts_with("type_rules") && s.contains('[') { in_type_rules = true; continue; }
|
||||
if in_type_rules {
|
||||
if s.starts_with(']') { in_type_rules = false; continue; }
|
||||
// Expect lines like: { left = "String", right = "String", result = "String", action = "concat" },
|
||||
if s.starts_with('{') && s.ends_with("},") || s.ends_with('}') {
|
||||
let inner = s.trim_start_matches('{').trim_end_matches('}').trim_end_matches(',');
|
||||
let mut left = String::new();
|
||||
let mut right = String::new();
|
||||
let mut result = String::new();
|
||||
let mut action = String::new();
|
||||
for part in inner.split(',') {
|
||||
let kv = part.trim();
|
||||
if let Some(eq) = kv.find('=') {
|
||||
let key = kv[..eq].trim();
|
||||
let val = kv[eq+1..].trim().trim_matches('"').to_string();
|
||||
match key {
|
||||
"left" => left = val,
|
||||
"right" => right = val,
|
||||
"result" => result = val,
|
||||
"action" => action = val,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
if !left.is_empty() && !right.is_empty() && !result.is_empty() && !action.is_empty() {
|
||||
if in_operators_add { add_rules.push((left, right, result, action)); }
|
||||
else if in_operators_sub { sub_rules.push((left, right, result, action)); }
|
||||
else if in_operators_mul { mul_rules.push((left, right, result, action)); }
|
||||
else if in_operators_div { div_rules.push((left, right, result, action)); }
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(rest) = s.strip_prefix("coercion_strategy") {
|
||||
if let Some(eq) = rest.find('=') {
|
||||
let val = rest[eq+1..].trim().trim_matches('"').to_string();
|
||||
if in_operators_add { add_coercion = Some(val.clone()); }
|
||||
else if in_operators_sub { sub_coercion = Some(val.clone()); }
|
||||
else if in_operators_mul { mul_coercion = Some(val.clone()); }
|
||||
else if in_operators_div { div_coercion = Some(val.clone()); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Default rules if none present in TOML (keep codegen deterministic)
|
||||
if add_rules.is_empty() {
|
||||
add_rules.push(("String".into(), "String".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("String".into(), "Integer".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("Integer".into(), "String".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("String".into(), "Bool".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("Bool".into(), "String".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("String".into(), "Other".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("Other".into(), "String".into(), "String".into(), "concat".into()));
|
||||
add_rules.push(("Integer".into(), "Integer".into(), "Integer".into(), "add_i64".into()));
|
||||
add_rules.push(("Float".into(), "Float".into(), "Float".into(), "add_f64".into()));
|
||||
}
|
||||
if sub_rules.is_empty() {
|
||||
sub_rules.push(("Integer".into(), "Integer".into(), "Integer".into(), "sub_i64".into()));
|
||||
sub_rules.push(("Float".into(), "Float".into(), "Float".into(), "sub_f64".into()));
|
||||
}
|
||||
if mul_rules.is_empty() {
|
||||
mul_rules.push(("Integer".into(), "Integer".into(), "Integer".into(), "mul_i64".into()));
|
||||
mul_rules.push(("Float".into(), "Float".into(), "Float".into(), "mul_f64".into()));
|
||||
}
|
||||
if div_rules.is_empty() {
|
||||
div_rules.push(("Integer".into(), "Integer".into(), "Integer".into(), "div_i64".into()));
|
||||
div_rules.push(("Float".into(), "Float".into(), "Float".into(), "div_f64".into()));
|
||||
}
|
||||
|
||||
// Generate Rust code
|
||||
let mut code = String::new();
|
||||
code.push_str("// Auto-generated from grammar/unified-grammar.toml\n");
|
||||
code.push_str("pub static KEYWORDS: &[(&str, &str)] = &[\n");
|
||||
for (k, t) in &entries {
|
||||
code.push_str(&format!(" (\"{}\", \"{}\"),\n", k, t));
|
||||
}
|
||||
code.push_str("];");
|
||||
let add_coercion_val = add_coercion.unwrap_or_else(|| "string_priority".to_string());
|
||||
let sub_coercion_val = sub_coercion.unwrap_or_else(|| "numeric_only".to_string());
|
||||
let mul_coercion_val = mul_coercion.unwrap_or_else(|| "numeric_only".to_string());
|
||||
let div_coercion_val = div_coercion.unwrap_or_else(|| "numeric_only".to_string());
|
||||
code.push_str(&format!("\npub static OPERATORS_ADD_COERCION: &str = \"{}\";\n", add_coercion_val));
|
||||
code.push_str(&format!("pub static OPERATORS_SUB_COERCION: &str = \"{}\";\n", sub_coercion_val));
|
||||
code.push_str(&format!("pub static OPERATORS_MUL_COERCION: &str = \"{}\";\n", mul_coercion_val));
|
||||
code.push_str(&format!("pub static OPERATORS_DIV_COERCION: &str = \"{}\";\n", div_coercion_val));
|
||||
// Emit add rules
|
||||
code.push_str("pub static OPERATORS_ADD_RULES: &[(&str, &str, &str, &str)] = &[\n");
|
||||
for (l, r, res, act) in &add_rules {
|
||||
code.push_str(&format!(" (\"{}\", \"{}\", \"{}\", \"{}\"),\n", l, r, res, act));
|
||||
}
|
||||
code.push_str("];");
|
||||
// Emit sub rules
|
||||
code.push_str("\npub static OPERATORS_SUB_RULES: &[(&str, &str, &str, &str)] = &[\n");
|
||||
for (l, r, res, act) in &sub_rules {
|
||||
code.push_str(&format!(" (\"{}\", \"{}\", \"{}\", \"{}\"),\n", l, r, res, act));
|
||||
}
|
||||
code.push_str("];");
|
||||
// Emit mul rules
|
||||
code.push_str("\npub static OPERATORS_MUL_RULES: &[(&str, &str, &str, &str)] = &[\n");
|
||||
for (l, r, res, act) in &mul_rules {
|
||||
code.push_str(&format!(" (\"{}\", \"{}\", \"{}\", \"{}\"),\n", l, r, res, act));
|
||||
}
|
||||
code.push_str("];");
|
||||
// Emit div rules
|
||||
code.push_str("\npub static OPERATORS_DIV_RULES: &[(&str, &str, &str, &str)] = &[\n");
|
||||
for (l, r, res, act) in &div_rules {
|
||||
code.push_str(&format!(" (\"{}\", \"{}\", \"{}\", \"{}\"),\n", l, r, res, act));
|
||||
}
|
||||
code.push_str("];");
|
||||
code.push_str(
|
||||
r#"
|
||||
pub fn lookup_keyword(word: &str) -> Option<&'static str> {
|
||||
for (k, t) in KEYWORDS {
|
||||
if *k == word { return Some(*t); }
|
||||
}
|
||||
None
|
||||
}
|
||||
"#);
|
||||
|
||||
// --- Naive parse for syntax rules (statements/expressions) ---
|
||||
let mut syntax_statements: Vec<String> = Vec::new();
|
||||
let mut syntax_binops: Vec<String> = Vec::new();
|
||||
let mut in_syntax_statements = false;
|
||||
let mut in_syntax_expressions = false;
|
||||
for line in content.lines() {
|
||||
let s = line.trim();
|
||||
if s == "[syntax.statements]" { in_syntax_statements = true; in_syntax_expressions = false; continue; }
|
||||
if s == "[syntax.expressions]" { in_syntax_statements = false; in_syntax_expressions = true; continue; }
|
||||
if s.starts_with('[') { in_syntax_statements = false; in_syntax_expressions = false; }
|
||||
if in_syntax_statements {
|
||||
if let Some(rest) = s.strip_prefix("allow") {
|
||||
if let Some(eq) = rest.find('=') { let arr = rest[eq+1..].trim();
|
||||
// Expect [ "if", "loop", ... ] possibly spanning multiple lines; simple split for this snapshot
|
||||
for part in arr.trim_matches(&['[',']'][..]).split(',') {
|
||||
let v = part.trim().trim_matches('"'); if !v.is_empty() { syntax_statements.push(v.to_string()); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if in_syntax_expressions {
|
||||
if let Some(rest) = s.strip_prefix("allow_binops") {
|
||||
if let Some(eq) = rest.find('=') { let arr = rest[eq+1..].trim();
|
||||
for part in arr.trim_matches(&['[',']'][..]).split(',') {
|
||||
let v = part.trim().trim_matches('"'); if !v.is_empty() { syntax_binops.push(v.to_string()); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if syntax_statements.is_empty() {
|
||||
syntax_statements = vec![
|
||||
"box".into(), "global".into(), "function".into(), "static".into(),
|
||||
"if".into(), "loop".into(), "break".into(), "return".into(), "print".into(),
|
||||
"nowait".into(), "include".into(), "local".into(), "outbox".into(), "try".into(), "throw".into(), "using".into(), "from".into()
|
||||
];
|
||||
}
|
||||
if syntax_binops.is_empty() {
|
||||
syntax_binops = vec!["add".into(), "sub".into(), "mul".into(), "div".into()];
|
||||
}
|
||||
// Emit syntax arrays
|
||||
code.push_str("\npub static SYNTAX_ALLOWED_STATEMENTS: &[&str] = &[\n");
|
||||
for k in &syntax_statements { code.push_str(&format!(" \"{}\",\n", k)); }
|
||||
code.push_str("];");
|
||||
code.push_str("\npub static SYNTAX_ALLOWED_BINOPS: &[&str] = &[\n");
|
||||
for k in &syntax_binops { code.push_str(&format!(" \"{}\",\n", k)); }
|
||||
code.push_str("];");
|
||||
|
||||
fs::write(&out_file, code).expect("write generated.rs");
|
||||
println!("cargo:rerun-if-changed={}", grammar_file.display());
|
||||
}
|
||||
Reference in New Issue
Block a user