Fix some parsing bugs and allow running files

src/lisp.c

@@ -589,7 +589,7 @@ DEFUN(backtrace, "backtrace", ()) {
 
 DEFUN(throw, "throw", (LispVal * signal, LispVal *rest)) {
     CHECK_TYPE(TYPE_SYMBOL, signal);
-    LispVal *backtrace = Fbacktrace();
+    LispVal *error_arg = make_list(2, Fpair(signal, rest), Fbacktrace());
     for (; the_stack; stack_leave()) {
         if (!the_stack->enable_handlers) {
             continue;
@@ -608,10 +608,9 @@ DEFUN(throw, "throw", (LispVal * signal, LispVal *rest)) {
                 the_stack->hidden = true;
                 if (!NILP(var)) {
                     // TODO make sure this isn't constant
-                    Fputhash(the_stack->lexenv, var,
-                             make_list(2, Fpair(signal, rest), backtrace));
+                    Fputhash(the_stack->lexenv, var, error_arg);
                 }
-                WITH_CLEANUP(backtrace, {
+                WITH_CLEANUP(error_arg, {
                     IGNORE_REF(Feval(form)); //
                 });
             });
@@ -619,7 +618,7 @@ DEFUN(throw, "throw", (LispVal * signal, LispVal *rest)) {
         }
     }
     // we never used it, so drop it
-    lisp_unref(backtrace);
+    lisp_unref(error_arg);
     fprintf(stderr,
             "ERROR: An exception has propogated past the top of the stack!\n");
     fprintf(stderr, "Type: ");
@@ -633,6 +632,7 @@ DEFUN(throw, "throw", (LispVal * signal, LispVal *rest)) {
 DEF_STATIC_SYMBOL(shutdown_signal, "shutdown-signal");
 DEF_STATIC_SYMBOL(type_error, "type-error");
 DEF_STATIC_SYMBOL(read_error, "read-error");
+DEF_STATIC_SYMBOL(eof_error, "eof-error");
 DEF_STATIC_SYMBOL(void_variable_error, "void-variable-error");
 DEF_STATIC_SYMBOL(void_function_error, "void-function-error");
 DEF_STATIC_SYMBOL(circular_error, "circular-error");
@@ -654,6 +654,13 @@ void lisp_init() {
     REGISTER_SYMBOL(tail);
     REGISTER_SYMBOL(quote);
     REGISTER_SYMBOL(exit);
+    REGISTER_SYMBOL(print);
+    REGISTER_SYMBOL(println);
+    REGISTER_SYMBOL(not);
+    REGISTER_SYMBOL(when);
+    REGISTER_SYMBOL(add);
+    REGISTER_SYMBOL(if);
+    REGISTER_SYMBOL(setq);
 #undef REGISTER_SYMBOL
 }
 
@@ -883,6 +890,65 @@ DEFMACRO(quote, "'", (LispVal * form)) {
     return form;
 }
 
+DEFUN(print, "print", (LispVal * obj)) {
+    debug_dump(stdout, obj, false);
+    return Qnil;
+}
+
+DEFUN(println, "println", (LispVal * obj)) {
+    debug_dump(stdout, obj, true);
+    return Qnil;
+}
+
+DEFUN(not, "not", (LispVal * obj)) {
+    return NILP(obj) ? Qt : Qnil;
+}
+
+DEFMACRO(if, "if", (LispVal * cond, LispVal *t, LispVal *nil)) {
+    LispVal *res = Feval(cond);
+    LispVal *retval = Qnil;
+    WITH_PUSH_FRAME(Qnil, Qnil, true, {
+        the_stack->hidden = true;
+        if (!NILP(res)) {
+            retval = Feval(t);
+        } else {
+            retval = Feval(nil);
+        }
+    });
+    return retval;
+}
+
+DEFMACRO(when, "when", (LispVal * cond, LispVal *t)) {
+    return Fif(cond, t, Qnil);
+}
+
+DEFUN(add, "+", (LispVal * n1, LispVal *n2)) {
+    if (INTEGERP(n1) && INTEGERP(n2)) {
+        return make_lisp_integer(((LispInteger *) n1)->value
+                                 + ((LispInteger *) n2)->value);
+    } else if (INTEGERP(n1) && FLOATP(n2)) {
+        return make_lisp_float(((LispInteger *) n1)->value
+                               + ((LispFloat *) n2)->value);
+    } else if (FLOATP(n1) && INTEGERP(n2)) {
+        return make_lisp_float(((LispFloat *) n1)->value
+                               + ((LispInteger *) n2)->value);
+    } else if (FLOATP(n1) && FLOATP(n2)) {
+        return make_lisp_float(((LispFloat *) n1)->value
+                               + ((LispFloat *) n2)->value);
+    } else {
+        Fthrow(Qtype_error, Qnil);
+    }
+}
+
+DEFMACRO(setq, "setq", (LispVal * name, LispVal *value)) {
+    CHECK_TYPE(TYPE_SYMBOL, name);
+    LispSymbol *sym = (LispSymbol *) name;
+    LispVal *evaled = Feval(value);
+    lisp_unref(sym->value);
+    sym->value = lisp_ref(evaled);
+    return evaled;
+}
+
 static void debug_dump_real(FILE *stream, void *obj, bool first) {
     switch (TYPEOF(obj)) {
     case TYPE_STRING: {