ability to pass parameters to the non-main entrypoint

samples/not_main_params.tri

···
+proc not_main!(a, b) {
+    exit a + b
+}
+
+export not_main

trilogy-codegen/src/context/program_context.rs

···
     }
 
     /// Writes the entrypoint of the program.
-    pub fn write_main(&mut self, path: &[&str], default_exit: Value) {
+    pub fn write_main(&mut self, path: &[&str], parameters: Vec<Value>, default_exit: Value) {
         let start = self.ip();
         self.entrypoint()
             .label("trilogy:__entrypoint__")
···
         for seg in path {
             self.atom(seg).call_module();
         }
-        self.call_procedure(0)
+        let len = parameters.len();
+        for param in parameters {
+            self.constant(param);
+        }
+        self.call_procedure(len)
             .instruction(Instruction::Copy)
             .instruction(Instruction::Unit)
             .instruction(Instruction::ValEq)

trilogy-codegen/src/entrypoint.rs

···
     builder: &mut ChunkBuilder,
     module: &ir::Module,
     entry_path: &[&str],
+    parameters: Vec<Value>,
 ) {
     let mut context = ProgramContext::new(file, builder);
-    context.write_main(entry_path, 0.into());
+    context.write_main(entry_path, parameters, 0.into());
     write_preamble(&mut context);
 
     let mut statics = HashMap::default();
···
     let mut context = ProgramContext::new(file, builder);
     let mut full_path = path.to_vec();
     full_path.push("trilogy:__testentry__");
-    context.write_main(&full_path, Value::Unit);
+    context.write_main(&full_path, vec![], Value::Unit);
     write_preamble(&mut context);
 
     let mut statics = HashMap::default();

trilogy/src/trilogy/mod.rs

···
 
     /// Runs the loaded Trilogy program by evaluating `main!()`.
     ///
-    /// This is equivalent to `call("main")`.
+    /// This is equivalent to `self.call("main", vec![])`.
     pub fn run(&self) -> Result<Value, RuntimeError> {
-        self.call("main")
+        self.call("main", vec![])
     }
 
     /// Runs the loaded Trilogy, evaluating the exported 0-arity procedure pointed to by
···
     /// is returned. Unfortunately at this time, those errors are hard to
     /// diagnose and could be anything from a bug in the compiler to an error
     /// in the Trilogy program.
-    pub fn call(&self, main: impl ModulePath) -> Result<Value, RuntimeError> {
+    pub fn call(
+        &self,
+        main: impl ModulePath,
+        parameters: Vec<Value>,
+    ) -> Result<Value, RuntimeError> {
         let result = match &self.source {
             Source::Asm { asm } => self.vm.run_with_registers(
                 &AsmProgram {
···
                     modules,
                     entrypoint,
                     path: &main.path(),
+                    parameters,
                     to_asm: false,
                 },
                 Self::default_registers(),
···
                 modules,
                 entrypoint,
                 path: &["main"],
+                parameters: vec![],
                 to_asm: true,
             }),
         }
···
                 modules,
                 entrypoint,
                 path: &["main"],
+                parameters: vec![],
                 to_asm: false,
             }),
         }

trilogy/src/trilogy/trilogy_program.rs

···
     pub libraries: &'a HashMap<Location, Native>,
     pub entrypoint: &'a Location,
     pub path: &'a [&'a str],
+    pub parameters: Vec<Value>,
     pub to_asm: bool,
 }
 
···
         let time_generating = Instant::now();
         let module = self.modules.get(self.entrypoint).unwrap();
         let url = self.entrypoint.as_ref().as_str();
-        trilogy_codegen::write_program(url, chunk, module, self.path);
+        trilogy_codegen::write_program(url, chunk, module, self.path, self.parameters.clone());
         log::trace!("entrypoint written: {:?}", time_generating.elapsed());
     }
 

trilogy/tests/samples.rs

···
         .is_library(true)
         .build_from_source(PathBuf::from(TEST_DIR).join("not_main.tri"))
         .unwrap();
-    assert_eq!(program.call("not_main").unwrap(), Value::from(6));
+    assert_eq!(program.call("not_main", vec![]).unwrap(), Value::from(6));
+}
+
+#[test]
+fn sample_not_main_params() {
+    let program = Builder::new()
+        .is_library(true)
+        .build_from_source(PathBuf::from(TEST_DIR).join("not_main_params.tri"))
+        .unwrap();
+    assert_eq!(
+        program
+            .call("not_main", vec![Value::from(1), Value::from(2)])
+            .unwrap(),
+        Value::from(3)
+    );
 }