Will REPL until quit called

Author: lastcraft

build

@@ -1,3 +1,3 @@
 yacc -d parser.y
 lex parser.l
-cc lex.yy.c y.tab.c type.c nil.c atoms.c pair.c stack.c exception.c dictionary.c function.c standard_library.c interpreter.c repl.c -ll -ly -o lisp
+cc lex.yy.c y.tab.c type.c nil.c atoms.c pair.c stack.c exception.c dictionary.c function.c exit.c standard_library.c interpreter.c repl.c -ll -ly -o lisp

exit.c

@@ -0,0 +1,23 @@
+#include "exit.h"
+#include "type.h"
+#include <stdlib.h>
+
+static void exit_code_writer(void *, Printf);
+
+void declare_exit_code(void) {
+    declare(free, exit_code_writer);
+}
+
+Object *exit_code(int code) {
+    int *cell = (int *)malloc(sizeof(int));
+    *cell = code;
+    return wrap(exit_code_type, cell);
+}
+
+int is_exit_code(Object *object) {
+    return is_a(exit_code_type, object);
+}
+
+static void exit_code_writer(void *code, Printf printer) {
+    printer("%d", *(int *)code);
+}

exit.h

@@ -0,0 +1,12 @@
+#ifndef EXIT_HEADER
+#define EXIT_HEADER
+
+#include "type.h"
+
+Type *exit_code_type;
+
+void declare_exit_code(void);
+Object *exit_code(int);
+int is_exit_code(Object *);
+
+#endif

interpreter.c

@@ -2,19 +2,22 @@
 #include "nil.h"
 #include "atoms.h"
 #include "pair.h"
+#include "exit.h"
 #include "function.h"
 #include "dictionary.h"
 #include "standard_library.h"
 
 static Dictionary *dictionary;
 static Object *eval_call(Object *, Object *, ErrorHandler, Dictionary *);
+static Object *eval_identifier(Object *, ErrorHandler, Dictionary *);
 static Object *execute(Callable, Object *, ErrorHandler, Dictionary *);
 
 void create_interpreter(void) {
     declare_nil();
     declare_atoms();
     declare_pair();
     declare_functions();
+    declare_exit_code();
     dictionary = create_dictionary();
     declare_standard_library(dictionary);
 }
@@ -33,6 +36,8 @@ Object *eval(Object *object, ErrorHandler error, Dictionary *dictionary) {
         Object *result = eval_call(clone(car(object)), clone(cdr(object)), error, dictionary);
         destroy(object);
         return result;
+    } else if (is_identifier(object)) {
+        return eval_identifier(object, error, dictionary);
     } else {
         return object;
     }
@@ -63,6 +68,15 @@ static Object *eval_call(Object *identifier, Object *arguments, ErrorHandler err
     return apply(function, arguments, error, dictionary);
 }
 
+static Object *eval_identifier(Object *identifier, ErrorHandler error, Dictionary *dictionary) {
+    Object *found;
+    if (! (found = find(dictionary, (char *)value(identifier)))) {
+        return error("Unkown identifier", identifier);
+    } else {
+        return clone(found);
+    }
+}
+
 static Object *execute(Callable built_in, Object *arguments, ErrorHandler error, Dictionary *dictionary) {
     return (*built_in)(arguments, error, dictionary);
 }

repl.c

@@ -2,27 +2,47 @@
 #include "nil.h"
 #include "pair.h"
 #include "exception.h"
+#include "exit.h"
 #include "interpreter.h"
 #include <stdio.h>
 
 extern void create_reader(void);
 extern void free_reader(void);
 extern Object *read(void);
 
+static int exit_status = 0;
+static int request_exit = 0;
+static void will_exit(int);
+static int exiting(void);
 static void print(Object *value);
 static void print_error(char *, Object *);
 
 int main(int argc, char **argv) {
     create_interpreter();
     create_reader();
-    Try {
-        print(eval(read(), throw_exception, top_level()));
-    } Catch {
-        print_error(exception_message(), (Object *)exception_information());
-    }
+    do {
+        Try {
+            print(eval(read(), throw_exception, top_level()));
+        } Catch {
+            if (is_exit_code((Object *)exception_information())) {
+                will_exit(*(int *)value((Object *)exception_information()));
+            } else {
+                print_error(exception_message(), (Object *)exception_information());
+            }
+        }
+    } while (! exiting());
     free_reader();
     free_interpreter();
-    return 0;
+    return exit_status;
+}
+
+static void will_exit(int exit_code) {
+    request_exit = 1;
+    exit_status = exit_code;
+}
+
+static int exiting(void) {
+    return request_exit;
 }
 
 static void print(Object *value) {

standard_library.c

@@ -5,15 +5,24 @@
 #include "nil.h"
 #include "atoms.h"
 #include "pair.h"
+#include "exit.h"
 
+static Object *quit(Object *, ErrorHandler, Dictionary *);
 static Object *set(Object *, ErrorHandler, Dictionary *);
 static Object *plus(Object *, ErrorHandler, Dictionary *);
 
 void declare_standard_library(Dictionary *dictionary) {
+    add(dictionary, "quit", built_in(quit));
     add(dictionary, "set", built_in(set));
     add(dictionary, "+", built_in(plus));
 }
 
+static Object *quit(Object *object, ErrorHandler error, Dictionary *dictionary) {
+    Object *code = exit_code(is_number(object) ? (int)value(object) : 0);
+    destroy(object);
+    return error("Quitting", code);
+}
+
 static Object *set(Object *arguments, ErrorHandler error, Dictionary *dictionary) {
     char *identifier = value(car(arguments));
     add(dictionary, identifier, clone(cdr(arguments)));