Enhance error handling and reporting in XPL interpreter; add ANSI color support for error messages, implement function and variable call statements, and improve parsing logic for better diagnostics.

omdxp · omdxp · commit 05a21d01245a · 2025-04-24T23:55:06.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 xmltree = "0.11.0"
 thiserror = "2.0.12"
+ansi_term = "0.12"
diff --git a/examples/bad_var.xpl b/examples/bad_var.xpl
@@ -0,0 +1,7 @@
+<program name="bad_var" version="1.0">
+  <function name="main">
+    <body>
+      <print>foo</print>
+    </body>
+  </function>
+</program>
diff --git a/src/error.rs b/src/error.rs
@@ -4,12 +4,61 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum XplError {
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
+    #[error("IO error in {file}: {source}")]
+    Io {
+        source: std::io::Error,
+        file: String,
+    },
 
-    #[error("XML parse error: {0}")]
-    Xml(#[from] xmltree::ParseError),
+    #[error("XML parse error in {file}: {source}")]
+    Xml {
+        source: xmltree::ParseError,
+        file: String,
+    },
 
-    #[error("Semantic error: {0}")]
-    Semantic(String),
+    #[error("{file}:{line}:{col}: {msg}")]
+    Semantic {
+        msg: String,
+        file: String,
+        line: usize,
+        col: usize,
+    },
+}
+
+impl XplError {
+    /// Print the error with colors and source arrow
+    pub fn pretty_print(&self) {
+        use ansi_term::Colour::{Blue, Red, Yellow};
+        match self {
+            XplError::Io { source, file } => {
+                eprintln!("{}: {} in file {}", Red.bold().paint("error"), source, file);
+            }
+            XplError::Xml { source, file } => {
+                eprintln!("{}: {} in file {}", Red.bold().paint("error"), source, file);
+            }
+            XplError::Semantic {
+                msg,
+                file,
+                line,
+                col,
+            } => {
+                // header
+                eprintln!("{}: {}", Red.bold().paint("error"), Yellow.paint(msg));
+                // location
+                eprintln!("  {} {}:{}:{}", Blue.paint("-->"), file, line, col);
+                // source context
+                if let Ok(src) = std::fs::read_to_string(file) {
+                    if let Some(src_line) = src.lines().nth(*line - 1) {
+                        // blank gutter line
+                        eprintln!("  {}", Blue.paint("|"));
+                        // code line without number
+                        eprintln!("  {} {}", Blue.paint("|"), src_line);
+                        // arrow line (align caret under code)
+                        let indent = " ".repeat(col.saturating_sub(1));
+                        eprintln!("  {} {}{}", Blue.paint("|"), indent, Red.paint("^"));
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -13,7 +13,7 @@ pub fn run_file(path: &str) -> Result<Vec<String>, XplError> {
     if !program.functions.contains_key("main") {
         return Ok(Vec::new());
     }
-    let mut vm = vm::VM::new();
+    let mut vm = vm::VM::new(path.to_string());
     let outputs = vm.run(&program)?;
     Ok(outputs)
 }
@@ -64,4 +64,24 @@ mod tests {
         let outputs = run_file(path).unwrap();
         assert_eq!(outputs, vec!["x minus 5 is zero".to_string()]);
     }
+
+    #[test]
+    fn undefined_variable_error() {
+        let tmp = "<program name=\"err\" version=\"1.0\"><function name=\"main\"><body><print> y </print></body></function></program>";
+        let path = std::env::temp_dir().join("err.xpl");
+        std::fs::write(&path, tmp).unwrap();
+        let err = run_file(path.to_str().unwrap()).unwrap_err().to_string();
+        assert!(err.contains("Undefined variable y"));
+        assert!(err.contains(path.to_str().unwrap()));
+    }
+
+    #[test]
+    fn undefined_function_error() {
+        let tmp = "<program name=\"errf\" include=\"examples/math.xpl\" version=\"1.0\"><function name=\"main\"><body><call function=\"none\"><param>1</param></call></body></function></program>";
+        let path = std::env::temp_dir().join("errf.xpl");
+        std::fs::write(&path, tmp).unwrap();
+        let err = run_file(path.to_str().unwrap()).unwrap_err().to_string();
+        assert!(err.contains("Undefined function none"));
+        assert!(err.contains(path.to_str().unwrap()));
+    }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -1,12 +1,18 @@
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() {
     let args: Vec<String> = std::env::args().collect();
     if args.len() != 2 {
         eprintln!("Usage: {} <script.xpl>", args[0]);
         std::process::exit(1);
     }
-    let outputs = xpl::run_file(&args[1])?;
-    for line in outputs {
-        println!("{}", line);
+    match xpl::run_file(&args[1]) {
+        Ok(outputs) => {
+            for line in outputs {
+                println!("{}", line);
+            }
+        }
+        Err(e) => {
+            e.pretty_print();
+            std::process::exit(1);
+        }
     }
-    Ok(())
 }
diff --git a/src/parser.rs b/src/parser.rs
@@ -30,6 +30,7 @@ pub enum Stmt {
         else_body: Vec<Stmt>,
     },
     Return(Expr),
+    Call(String, Vec<Expr>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -52,17 +53,29 @@ pub enum Expr {
 
 /// Parse an XPL file into a Program AST
 pub fn parse_file(path: &str) -> Result<Program, XplError> {
-    let file = File::open(path)?;
-    let root = Element::parse(file)?;
+    let file = File::open(path).map_err(|e| XplError::Io {
+        source: e,
+        file: path.to_string(),
+    })?;
+    let root = Element::parse(file).map_err(|e| XplError::Xml {
+        source: e,
+        file: path.to_string(),
+    })?;
     let mut functions = HashMap::new();
     // Process include only for program roots (to load libs)
     if root.name == "program" {
         if let Some(include_list) = root.attributes.get("include") {
-            let base = std::path::Path::new(path)
+            let script_dir = std::path::Path::new(path)
                 .parent()
                 .unwrap_or_else(|| std::path::Path::new("."));
             for inc in include_list.split(',').map(|s| s.trim()) {
-                let inc_path = base.join(inc);
+                // try script-relative first, then workspace-relative
+                let rel_path = script_dir.join(inc);
+                let inc_path = if rel_path.exists() {
+                    rel_path
+                } else {
+                    std::path::Path::new(inc).to_path_buf()
+                };
                 let included = parse_file(inc_path.to_str().unwrap())?;
                 functions.extend(included.functions);
             }
@@ -88,8 +101,14 @@ pub fn parse_file(path: &str) -> Result<Program, XplError> {
                     for stmt_node in &body_elem.children {
                         if let XMLNode::Element(stmt_elem) = stmt_node {
                             match stmt_elem.name.as_str() {
+                                "call" => {
+                                    // standalone call statement
+                                    let expr = parse_expr(stmt_elem)?;
+                                    if let Expr::Call(name, args) = expr {
+                                        body.push(Stmt::Call(name, args));
+                                    }
+                                }
                                 "return" => {
-                                    // parse return expression
                                     let expr = if let Some(XMLNode::Element(e)) =
                                         stmt_elem.children.get(0)
                                     {
@@ -101,10 +120,14 @@ pub fn parse_file(path: &str) -> Result<Program, XplError> {
                                     body.push(Stmt::Return(expr));
                                 }
                                 "if" => {
-                                    // parse condition
                                     let cond_elem =
                                         stmt_elem.get_child("condition").ok_or_else(|| {
-                                            XplError::Semantic("Missing condition".to_string())
+                                            XplError::Semantic {
+                                                msg: "Missing condition".to_string(),
+                                                file: path.to_string(),
+                                                line: 0,
+                                                col: 0,
+                                            }
                                         })?;
                                     // either inner element or text
                                     let cond_expr = if let Some(XMLNode::Element(e)) =
@@ -126,7 +149,12 @@ pub fn parse_file(path: &str) -> Result<Program, XplError> {
                                     // then block
                                     let then_elem =
                                         stmt_elem.get_child("then").ok_or_else(|| {
-                                            XplError::Semantic("Missing then block".to_string())
+                                            XplError::Semantic {
+                                                msg: "Missing then block".to_string(),
+                                                file: path.to_string(),
+                                                line: 0,
+                                                col: 0,
+                                            }
                                         })?;
                                     let mut then_body = Vec::new();
                                     for then_node in &then_elem.children {
@@ -154,7 +182,12 @@ pub fn parse_file(path: &str) -> Result<Program, XplError> {
                                     // else block
                                     let else_elem =
                                         stmt_elem.get_child("else").ok_or_else(|| {
-                                            XplError::Semantic("Missing else block".to_string())
+                                            XplError::Semantic {
+                                                msg: "Missing else block".to_string(),
+                                                file: path.to_string(),
+                                                line: 0,
+                                                col: 0,
+                                            }
                                         })?;
                                     let mut else_body = Vec::new();
                                     for else_node in &else_elem.children {
diff --git a/src/vm.rs b/src/vm.rs
