Implement command line parser builtin

Cargo.toml

@@ -24,6 +24,8 @@ glob = "0.3"
 heraclitus-compiler = "1.8.1"
 include_dir = "0.7.4"
 itertools = "0.13.0"
+once_cell = "1.20.2"
+regex = "1.11.1"
 similar-string = "1.4.2"
 test-generator = "0.3.1"
 wildmatch = "2.4.0"

src/compiler.rs

@@ -12,11 +12,12 @@ use heraclitus_compiler::prelude::*;
 use itertools::Itertools;
 use wildmatch::WildMatchPattern;
 use std::env;
+use std::ffi::OsStr;
 use std::fs;
 use std::fs::File;
 use std::io::{ErrorKind, Write};
 use std::iter::once;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::{Command, ExitStatus};
 use std::time::Instant;
 
@@ -29,19 +30,23 @@ const AMBER_DEBUG_TIME: &str = "AMBER_DEBUG_TIME";
 pub struct CompilerOptions {
     pub no_proc: Vec<String>,
     pub minify: bool,
+    pub run_name: Option<String>,
 }
 
 impl Default for CompilerOptions {
     fn default() -> Self {
         let no_proc = vec![String::from("*")];
-        Self { no_proc, minify: false }
+        Self { no_proc, minify: false, run_name: None }
     }
 }
 
 impl CompilerOptions {
-    pub fn from_args(no_proc: &[String], minify: bool) -> Self {
+    pub fn from_args(no_proc: &[String], minify: bool, input: Option<&Path>) -> Self {
         let no_proc = no_proc.to_owned();
-        Self { no_proc, minify }
+        let run_name = input.and_then(Path::file_name)
+            .and_then(OsStr::to_str)
+            .map(String::from);
+        Self { no_proc, minify, run_name }
     }
 }
 
@@ -138,7 +143,7 @@ impl AmberCompiler {
         }
     }
 
-    pub fn get_sorted_ast_forest(
+    fn get_sorted_ast_forest(
         &self,
         block: Block,
         meta: &ParserMetadata,

src/main.rs

@@ -31,6 +31,7 @@ struct Cli {
 
     /// Arguments passed to Amber script
     #[arg(trailing_var_arg = true)]
+    #[arg(allow_hyphen_values = true)]
     args: Vec<String>,
 
     /// Disable a postprocessor
@@ -70,6 +71,7 @@ struct RunCommand {
 
     /// Arguments passed to Amber script
     #[arg(trailing_var_arg = true)]
+    #[arg(allow_hyphen_values = true)]
     args: Vec<String>,
 
     /// Disable a postprocessor
@@ -134,17 +136,17 @@ fn main() -> Result<(), Box<dyn Error>> {
                 handle_eval(command)?;
             }
             CommandKind::Run(command) => {
-                let options = CompilerOptions::from_args(&command.no_proc, false);
+                let options = CompilerOptions::from_args(&command.no_proc, false, Some(&command.input));
                 let (code, messages) = compile_input(command.input, options);
                 execute_output(code, command.args, messages)?;
             }
             CommandKind::Check(command) => {
-                let options = CompilerOptions::from_args(&command.no_proc, false);
+                let options = CompilerOptions::from_args(&command.no_proc, false, None);
                 compile_input(command.input, options);
             }
             CommandKind::Build(command) => {
                 let output = create_output(&command);
-                let options = CompilerOptions::from_args(&command.no_proc, command.minify);
+                let options = CompilerOptions::from_args(&command.no_proc, command.minify, None);
                 let (code, _) = compile_input(command.input, options);
                 write_output(output, code);
             }
@@ -156,7 +158,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             }
         }
     } else if let Some(input) = cli.input {
-        let options = CompilerOptions::from_args(&cli.no_proc, false);
+        let options = CompilerOptions::from_args(&cli.no_proc, false, Some(&input));
         let (code, messages) = compile_input(input, options);
         execute_output(code, cli.args, messages)?;
     }

src/modules/builtin/cli/getopt.rs

@@ -0,0 +1,63 @@
+use crate::docs::module::DocumentationModule;
+use crate::modules::builtin::cli::param::ParamImpl;
+use crate::modules::builtin::cli::parser::ParserImpl;
+use crate::modules::expression::expr::Expr;
+use crate::modules::types::{Type, Typed};
+use crate::translate::module::TranslateModule;
+use crate::utils::metadata::{ParserMetadata, TranslateMetadata};
+use heraclitus_compiler::prelude::*;
+use std::cell::RefCell;
+use std::rc::Rc;
+
+#[derive(Debug, Clone)]
+pub struct GetoptCli {
+    parser: Option<Rc<RefCell<ParserImpl>>>,
+    args: Box<Expr>,
+}
+
+impl Typed for GetoptCli {
+    fn get_type(&self) -> Type {
+        Type::Null
+    }
+}
+
+impl SyntaxModule<ParserMetadata> for GetoptCli {
+    syntax_name!("Getopt Invocation");
+
+    fn new() -> Self {
+        let args = Box::new(Expr::new());
+        Self { parser: None, args }
+    }
+
+    fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+        token(meta, "getopt")?;
+        let mut parser = Expr::new();
+        token(meta, "(")?;
+        let parser_tok = meta.get_current_token();
+        syntax(meta, &mut parser)?;
+        token(meta, ",")?;
+        syntax(meta, &mut *self.args)?;
+        token(meta, ")")?;
+        let parser = match ParserImpl::find_parser(meta, &parser) {
+            Some(parser) => parser,
+            None => return error!(meta, parser_tok, "Expected parser object"),
+        };
+        parser.borrow_mut().add_param(ParamImpl::help());
+        self.parser = Some(parser);
+        Ok(())
+    }
+}
+
+impl TranslateModule for GetoptCli {
+    fn translate(&self, meta: &mut TranslateMetadata) -> String {
+        self.parser.as_ref()
+            .map(|parser| parser.borrow().translate(meta, &self.args))
+            .unwrap_or_default()
+    }
+}
+
+impl DocumentationModule for GetoptCli {
+    fn document(&self, _meta: &ParserMetadata) -> String {
+        String::new()
+    }
+}

src/modules/builtin/cli/mod.rs

@@ -0,0 +1,3 @@
+pub mod getopt;
+pub mod param;
+pub mod parser;