cleanup and sicp file, but crashes

src/parse.cpp

@@ -111,7 +111,8 @@ namespace Parser {
         // dont create a String first
         String* str_number = read_atom(text, index_in_text);
         sscanf(Memory::get_c_str(str_number), "%lf", &number);
-        Lisp_Object* ret = Memory::create_lisp_object_number(number);
+        Lisp_Object* ret;
+        try ret = Memory::create_lisp_object_number(number);
 
         inject_scl(ret);
         return ret;
@@ -122,7 +123,8 @@ namespace Parser {
         ++(*index_in_text);
         ++parser_col;
         String* str_keyword = read_atom(text, index_in_text);
-        Lisp_Object* ret = Memory::get_or_create_lisp_object_keyword(str_keyword);
+        Lisp_Object* ret;
+        try ret = Memory::get_or_create_lisp_object_keyword(str_keyword);
 
         inject_scl(ret);
         return ret;
@@ -131,7 +133,9 @@ namespace Parser {
     proc parse_symbol(char* text, int* index_in_text) -> Lisp_Object* {
         // we are now at the first char of the symbol
         String* str_symbol = read_atom(text, index_in_text);
-        Lisp_Object* ret = Memory::get_or_create_lisp_object_symbol(str_symbol);
+        Lisp_Object* ret;
+        try ret = Memory::get_or_create_lisp_object_symbol(str_symbol);
+
         inject_scl(ret);
         return ret;
     }
@@ -144,7 +148,8 @@ namespace Parser {
         // now we are at the first letter, if this is the closing '"' then
         // it's easy
         if (text[*index_in_text] == '"') {
-            Lisp_Object* ret = Memory::create_lisp_object_string(
+            Lisp_Object* ret;
+            try ret = Memory::create_lisp_object_string(
                 Memory::create_string("", 0));
             inject_scl(ret);
 
@@ -200,7 +205,9 @@ namespace Parser {
             }
         }
 
-        Lisp_Object* ret = Memory::create_lisp_object_string(string);
+        Lisp_Object* ret;
+        try ret = Memory::create_lisp_object_string(string);
+
         inject_scl(ret);
         return ret;
     }
@@ -259,16 +266,17 @@ namespace Parser {
             }
 
             Lisp_Object* ret = nullptr;
+            // TODO(Felix): use Memory::create_list() here
             if (quoteType == '\'')
-                ret =  Memory::create_lisp_object_pair(
+                try ret = Memory::create_lisp_object_pair(
                     Memory::get_or_create_lisp_object_symbol("quote"),
                     Memory::create_lisp_object_pair(result, Memory::nil));
             else if (quoteType == '`')
-                ret =  Memory::create_lisp_object_pair(
+                try ret = Memory::create_lisp_object_pair(
                     Memory::get_or_create_lisp_object_symbol("quasiquote"),
                     Memory::create_lisp_object_pair(result, Memory::nil));
             else if (quoteType == ',')
-                ret =  Memory::create_lisp_object_pair(
+                try ret = Memory::create_lisp_object_pair(
                     Memory::get_or_create_lisp_object_symbol("unquote"),
                     Memory::create_lisp_object_pair(result, Memory::nil));
             inject_scl(ret);
@@ -291,7 +299,8 @@ namespace Parser {
         }
 
         // okay there is something
-        Lisp_Object* head = Memory::create_lisp_object();
+        Lisp_Object* head;
+        try head = Memory::create_lisp_object();
         Memory::set_type(head, Lisp_Object_Type::Pair);
         // head->value.pair = new(Pair);
         Lisp_Object* expression = head;
@@ -346,7 +355,7 @@ namespace Parser {
                 ++(*index_in_text);
                 break;
             } else {
-                head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
+                try head->value.pair.rest = Memory::create_lisp_object_pair(nullptr, nullptr);
                 head = head->value.pair.rest;
             }
         }
@@ -377,7 +386,8 @@ namespace Parser {
                 arguments = arguments->value.pair.first->value.pair.rest;
 
                 // Function* function = new(Function);
-                Lisp_Object* macro = Memory::create_lisp_object();
+                Lisp_Object* macro;
+                try macro = Memory::create_lisp_object();
                 Memory::set_type(macro, Lisp_Object_Type::Function);
                 macro->value.function.parent_environment = environment_for_macros;
                 macro->value.function.type = Function_Type::Macro;
@@ -403,7 +413,7 @@ namespace Parser {
 
                 // we are now in the function body, just wrap it in an
                 // implicit prog
-                macro->value.function.body = Memory::create_lisp_object_pair(
+                try macro->value.function.body = Memory::create_lisp_object_pair(
                     Memory::get_or_create_lisp_object_symbol("prog"),
                     body);
 
@@ -510,12 +520,12 @@ namespace Parser {
                 ++end_pos;
 
             text[end_pos] = '\0';
-            Lisp_Object* str = Memory::create_lisp_object_string(
+            Lisp_Object* str;
+            try str = Memory::create_lisp_object_string(
                 Memory::create_string(text+index_in_text));
             text[end_pos] = '\n';
 
-            return Memory::create_list(
-                Memory::get_or_create_lisp_object_symbol(bare), str);
+            return Memory::create_list(Memory::get_or_create_lisp_object_symbol(bare), str);
         }
 
     }