clean up

fix/src/main.rs

@@ -0,0 +1,151 @@
+use std::path::PathBuf;
+use std::process::exit;
+
+use anyhow::Result;
+use clap::{Args, Parser, Subcommand};
+use hashbrown::HashSet;
+use fix::context::Context;
+use fix::error::Source;
+use rustyline::DefaultEditor;
+use rustyline::error::ReadlineError;
+
+#[derive(Parser)]
+#[command(name = "nix-js", about = "Nix expression evaluator")]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    Compile {
+        #[clap(flatten)]
+        source: ExprSource,
+        #[arg(long)]
+        silent: bool,
+    },
+    Eval {
+        #[clap(flatten)]
+        source: ExprSource,
+    },
+    Repl,
+}
+
+#[derive(Args)]
+#[group(required = true, multiple = false)]
+struct ExprSource {
+    #[clap(short, long)]
+    expr: Option<String>,
+    #[clap(short, long)]
+    file: Option<PathBuf>,
+}
+
+fn run_compile(context: &mut Context, src: ExprSource, silent: bool) -> Result<()> {
+    let src = if let Some(expr) = src.expr {
+        Source::new_eval(expr)?
+    } else if let Some(file) = src.file {
+        Source::new_file(file)?
+    } else {
+        unreachable!()
+    };
+    match context.compile_bytecode(src) {
+        Ok(compiled) => {
+            if !silent {
+                println!("{}", context.disassemble_colored(&compiled));
+            }
+        }
+        Err(err) => {
+            eprintln!("{:?}", miette::Report::new(*err));
+            exit(1);
+        }
+    };
+    Ok(())
+}
+
+fn run_eval(context: &mut Context, src: ExprSource) -> Result<()> {
+    let src = if let Some(expr) = src.expr {
+        Source::new_eval(expr)?
+    } else if let Some(file) = src.file {
+        Source::new_file(file)?
+    } else {
+        unreachable!()
+    };
+    match context.eval_deep(src) {
+        Ok(value) => {
+            println!("{}", value.display_compat());
+        }
+        Err(err) => {
+            eprintln!("{:?}", miette::Report::new(*err));
+            exit(1);
+        }
+    };
+    Ok(())
+}
+
+fn run_repl(context: &mut Context) -> Result<()> {
+    let mut rl = DefaultEditor::new()?;
+    let mut scope = HashSet::new();
+    const RE: ere::Regex<3> = ere::compile_regex!("^[ \t]*([a-zA-Z_][a-zA-Z0-9_'-]*)[ \t]*(.*)$");
+    loop {
+        let readline = rl.readline("nix-js-repl> ");
+        match readline {
+            Ok(line) => {
+                if line.trim().is_empty() {
+                    continue;
+                }
+                let _ = rl.add_history_entry(line.as_str());
+                if let Some([Some(_), Some(ident), Some(rest)]) = RE.exec(&line) {
+                    if let Some(expr) = rest.strip_prefix('=') {
+                        let expr = expr.trim_start();
+                        if expr.is_empty() {
+                            eprintln!("Error: missing expression after '='");
+                            continue;
+                        }
+                        match context.add_binding(ident, expr, &mut scope) {
+                            Ok(value) => println!("{} = {}", ident, value),
+                            Err(err) => eprintln!("{:?}", miette::Report::new(*err)),
+                        }
+                    } else {
+                        let src = Source::new_repl(line)?;
+                        match context.eval_repl(src, &scope) {
+                            Ok(value) => println!("{value}"),
+                            Err(err) => eprintln!("{:?}", miette::Report::new(*err)),
+                        }
+                    }
+                } else {
+                    let src = Source::new_repl(line)?;
+                    match context.eval_shallow(src) {
+                        Ok(value) => println!("{value}"),
+                        Err(err) => eprintln!("{:?}", miette::Report::new(*err)),
+                    }
+                }
+            }
+            Err(ReadlineError::Interrupted) => {
+                println!();
+            }
+            Err(ReadlineError::Eof) => {
+                println!("CTRL-D");
+                break;
+            }
+            Err(err) => {
+                eprintln!("Error: {err:?}");
+                break;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    fix::logging::init_logging();
+
+    let cli = Cli::parse();
+
+    let mut context = Context::new()?;
+
+    match cli.command {
+        Command::Compile { source, silent } => run_compile(&mut context, source, silent),
+        Command::Eval { source } => run_eval(&mut context, source),
+        Command::Repl => run_repl(&mut context),
+    }
+}