vm

examples/fib-tail.lisp

@@ -6,4 +6,4 @@
   "Tail recursive Fib"
   (fib-impl n 0 1))
 
-(princ (fib 30))
+(print (fib 30))

examples/fib.lisp

@@ -4,5 +4,6 @@
       (+ (fib (- n 1))
          (fib (- n 2)))))
 
-(let ((tgt 30))
-  (print (format "\n  (fib %d)\n  %d\n" tgt (fib tgt))))
+(let* ((tgt 30)
+       (res (fib tgt)))
+  (print (format "\n  (fib %d)\n  %d\n" tgt res)))

examples/tail-recursion.lisp

@@ -2,4 +2,5 @@
   (if (equal counter 0) lis
       (build (- counter 1) (cons counter lis))))
 
-(princ (build 1000000 '()))
+(print (build 1000000 '()))
+

src/bin/tulisp_vm.rs

@@ -0,0 +1,15 @@
+use std::env;
+
+use tulisp::TulispContext;
+
+fn main() {
+    let mut ctx = TulispContext::new();
+    let args: Vec<String> = env::args().skip(1).collect();
+
+    for arg in args {
+        if let Err(e) = ctx.vm_eval_file(&arg) {
+            println!("{}", e.format(&ctx));
+            std::process::exit(-1);
+        }
+    }
+}

src/builtin/functions/functions.rs

@@ -3,6 +3,7 @@ use crate::TulispValue;
 use crate::cons::Cons;
 use crate::context::Scope;
 use crate::context::TulispContext;
+use crate::destruct_bind;
 use crate::destruct_eval_bind;
 use crate::error::Error;
 use crate::error::ErrorKind;
@@ -12,8 +13,8 @@ use crate::eval::eval;
 use crate::eval::eval_and_then;
 use crate::eval::eval_check_null;
 use crate::lists;
+use crate::parse::mark_tail_calls;
 use crate::value::DefunParams;
-use crate::{destruct_bind, list};
 use std::convert::TryInto;
 use std::rc::Rc;
 
@@ -33,63 +34,6 @@ pub(super) fn reduce_with(
     Ok(first)
 }
 
-fn mark_tail_calls(
-    ctx: &mut TulispContext,
-    name: TulispObject,
-    body: TulispObject,
-) -> Result<TulispObject, Error> {
-    if !body.consp() {
-        return Ok(body);
-    }
-    let ret = TulispObject::nil();
-    let mut body_iter = body.base_iter();
-    let mut tail = body_iter.next().unwrap();
-    for next in body_iter {
-        ret.push(tail)?;
-        tail = next;
-    }
-    if !tail.consp() {
-        return Ok(body);
-    }
-    let span = tail.span();
-    let ctxobj = tail.ctxobj();
-    let tail_ident = tail.car()?;
-    let tail_name_str = tail_ident.as_symbol()?;
-    let new_tail = if tail_ident.eq(&name) {
-        let ret_tail = TulispObject::nil().append(tail.cdr()?)?.to_owned();
-        list!(,ctx.intern("list")
-            ,TulispValue::Bounce.into_ref(None)
-            ,@ret_tail)?
-    } else if tail_name_str == "progn" || tail_name_str == "let" || tail_name_str == "let*" {
-        list!(,tail_ident ,@mark_tail_calls(ctx, name, tail.cdr()?)?)?
-    } else if tail_name_str == "if" {
-        destruct_bind!((_if condition then_body &rest else_body) = tail);
-        list!(,tail_ident
-            ,condition.clone()
-            ,mark_tail_calls(
-                ctx,
-                name.clone(),
-                list!(,then_body)?
-            )?.car()?
-            ,@mark_tail_calls(ctx, name, else_body)?
-        )?
-    } else if tail_name_str == "cond" {
-        destruct_bind!((_cond &rest conds) = tail);
-        let mut ret = list!(,tail_ident)?;
-        for cond in conds.base_iter() {
-            destruct_bind!((condition &rest body) = cond);
-            ret = list!(,@ret
-                ,list!(,condition.clone()
-                    ,@mark_tail_calls(ctx, name.clone(), body)?)?)?;
-        }
-        ret
-    } else {
-        tail
-    };
-    ret.push(new_tail.with_ctxobj(ctxobj).with_span(span))?;
-    Ok(ret)
-}
-
 pub(crate) fn add(ctx: &mut TulispContext) {
     ctx.add_special_form("load", |ctx, args| {
         destruct_eval_bind!(ctx, (filename) = args);
@@ -309,7 +253,8 @@ pub(crate) fn add(ctx: &mut TulispContext) {
                         "varitems inside a let-varlist should be a var or a binding: {}",
                         varitem
                     ),
-                ));
+                )
+                .with_trace(varitem.clone()));
             };
         }
 

src/bytecode/bytecode.rs

@@ -0,0 +1,42 @@
+use std::{cell::RefCell, collections::HashMap, fmt, rc::Rc};
+
+use super::Instruction;
+use crate::{bytecode::compiler::VMDefunParams, TulispObject};
+
+#[derive(Default, Clone)]
+pub(crate) struct CompiledDefun {
+    pub(crate) name: TulispObject,
+    pub(crate) instructions: Rc<RefCell<Vec<Instruction>>>,
+    pub(crate) params: VMDefunParams,
+}
+
+#[derive(Default, Clone)]
+pub(crate) struct Bytecode {
+    pub(crate) global: Rc<RefCell<Vec<Instruction>>>,
+    pub(crate) functions: HashMap<usize, CompiledDefun>, // key: fn_name.addr_as_usize()
+}
+
+impl fmt::Display for Bytecode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for (i, instr) in self.global.borrow().iter().enumerate() {
+            write!(f, "\n{:<40}   # {}", instr.to_string(), i)?;
+        }
+        for (name, func) in &self.functions {
+            write!(f, "\n\n{}:", name)?;
+            for (i, instr) in func.instructions.borrow().iter().enumerate() {
+                write!(f, "\n{:<40}   # {}", instr.to_string(), i)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Bytecode {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn import_functions(&mut self, other: &Bytecode) {
+        self.functions.extend(other.functions.clone());
+    }
+}