add quote syntax and binary executable

Author: gfaster

examples/collection.cl

@@ -3,8 +3,6 @@
        ;; (println num)
        ;; (setq num (- num 1))) ; num = num - 1
 
-(define nil (< 1 0))
-
 (defun reverse (lis)
   (define res)
   (while lis 
@@ -21,4 +19,13 @@
 	 (setq x (if lis (car lis) nil)))
   (reverse res))
 
-(println (map (quote (1 2 3 4 5 6 7)) (lambda (x) (+ x 5))))
+(defun seq (cnt)
+  (define ret)
+  (while (< 0 cnt)
+	 (setq ret (cons cnt ret))
+	 (setq cnt (- cnt 1)))
+  ret)
+
+(println 
+  (map (seq 15)
+       (lambda (x) (+ x 5))))

src/context.rs

@@ -224,24 +224,24 @@ impl<'a> RootRef<'a> {
     }
 
     pub fn make_list(self, l: impl IntoIterator<Item = impl ToLisp>) {
-        root!(next, cdr);
+        root!(next, car, ret, t1);
         let mut it = l.into_iter();
         if let Some(first) = it.next() {
-            first.to_lisp(cdr);
-            let first_cell = unsafe { Obj::new_pair(Pair { cdr: cdr.get(), car: Obj::nil() }) };
+            first.to_lisp(car);
+            let first_cell = unsafe { Obj::new_pair(Pair { car: car.get(), cdr: Obj::nil() }) };
             next.set(first_cell);
-            self.set(first_cell);
+            ret.set(first_cell);
             for num in it {
-                num.to_lisp(cdr);
-                let next_cell = unsafe { Obj::new_pair(Pair { cdr: cdr.get(), car: Obj::nil() }) };
-                root!(t1);
+                num.to_lisp(car);
+                let next_cell = unsafe { Obj::new_pair(Pair { car: car.get(), cdr: Obj::nil() }) };
                 t1.set(next_cell);
-                next.set_car(t1);
+                next.set_cdr(t1);
                 t1.copy_to(next);
             }
         } else {
-            self.set(Obj::nil())
+            ret.set(Obj::nil())
         }
+        ret.copy_to(self)
     }
 
     pub fn make_string(self, s: impl AsRef<str>) {
@@ -397,3 +397,15 @@ impl std::fmt::Debug for RootRef<'_> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn make_lists() {
+        root!(val);
+        (1, 2, 3).to_lisp(val);
+        assert_eq!(format!("{val:?}"), "(1 2 3)")
+    }
+}

src/context/eval.rs

@@ -49,7 +49,7 @@ pub(crate) fn progn(env: RootRef, list: RootRef) -> Obj {
     root!(it, ret);
     list.copy_to(it);
     for val in it.to_list_iter(ret) {
-        eprintln!("progn stmt: {val:?}");
+        // eprintln!("progn stmt: {val:?}");
         ret.set(eval(env, val));
     }
     return ret.get();

src/main.rs

@@ -1,3 +1,14 @@
-fn main() {
-    println!("Hello, world!");
+use std::error::Error;
+
+fn usage() -> String {
+    let exe = std::env::args().next().unwrap_or_else(|| "grel".into());
+    format!("usage: {exe} <file>")
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let program = std::env::args_os().nth(1).ok_or_else(usage)?;
+    let content = std::fs::read_to_string(program)?;
+    grel::exec_expr(&content);
+
+    Ok(())
 }

src/parse.rs

@@ -1,9 +1,10 @@
-use std::iter::Peekable;
+use std::{borrow::Cow, iter::Peekable};
 
-use crate::{intern::intern, root, Obj};
+use crate::{intern::intern, root, Obj, ToLisp};
 
 enum Tok<'a> {
-    Str(&'a str),
+    #[expect(dead_code)]
+    Str(Cow<'a, str>),
     Sym(&'a str),
     Num(i64),
     Quote,
@@ -54,10 +55,6 @@ impl<'a> Iterator for Lex<'a> {
                 ';' => {
                     self.take_until(|c| c == '\n');
                 },
-                c if c.is_whitespace() => {
-                    self.take_char();
-                    continue
-                },
                 '-' => {
                     let s = self.take_until(term_end);
                     if s.chars().skip(1).next().map_or(false, |c| c.is_ascii_digit()) {
@@ -90,6 +87,10 @@ impl<'a> Iterator for Lex<'a> {
                     self.take_char();
                     return Some(Tok::Dot);
                 }
+                c if c.is_whitespace() => {
+                    self.take_char();
+                    continue
+                },
                 _ => {
                     let sym = self.take_until(term_end);
                     assert!(valid_sym(sym), "{sym} is invalid symbol");
@@ -155,9 +156,19 @@ fn parse_expr(lex: &mut PLex) -> ExprRes {
     };
     match tok {
         Tok::Str(_) => todo!(),
+        Tok::Sym("nil") => ExprRes::Obj(Obj::nil()),
         Tok::Sym(s) => ExprRes::Obj(intern(s)),
         Tok::Num(i) => ExprRes::Obj(Obj::from_num(i)),
-        Tok::Quote => todo!(),
+        Tok::Quote => {
+            root!(quote, expr, res);
+            let ExprRes::Obj(val) = parse_expr(lex) else {
+                panic!("unfinished quote");
+            };
+            expr.set(val);
+            quote.set(intern("quote"));
+            (quote, expr).to_lisp(res);
+            ExprRes::Obj(res.get())
+        },
         Tok::OpenParen => ExprRes::Obj(parse_list(lex)),
         Tok::CloseParen => ExprRes::Close,
         Tok::Dot => ExprRes::Dot,