Some clean-up. Removed NO_REPL (redundant via cli)

src/Makefile

@@ -4,8 +4,5 @@ all:
 debug:
 	gcc -g -O0 -o pebblisp -D STANDALONE -D DEBUG pebblisp.c tokens.c object.c env.c && ./tests.sh
 
-phrase:
-	gcc -g -O0 -o pebblisp -D STANDALONE -D DEBUG -D NO_REPL pebblisp.c tokens.c object.c env.c && ./tests.sh
-
 run:
 	./pebblisp

src/pebblisp.c

@@ -19,6 +19,10 @@ void copySlice(char * dest, struct Slice *src)
 
 void debugSlice(struct Slice *s)
 {
+    if(!s) {
+        printd("NULL SLICE\n");
+        return;
+    }
     printd("Debug Slice\n    text:'");
     for(int i = 0; i < s->length; i++) {
         printd("%c", s->text[i]);
@@ -32,19 +36,17 @@ void debugSlice(struct Slice *s)
 Result parse(struct Slice *slices)
 {
     struct Slice *token = slices;
-    struct Slice *rest;
+    if(token && token->text) {
-    if(token->text != NULL) {
+        struct Slice *rest = &slices[1];
-        rest = &slices[1];
-    } else {
-        return result(errorObject(NULL_PARSE), NULL);
-    }
-
         if(token->text[0] == '(') {
             // todo check for null rest
             return readSeq(rest);
         } else { // todo error on missing close paren
             return result(parseAtom(token), rest);
         }
+    } else {
+        return result(errorObject(NULL_PARSE), NULL);
+    }
 }
 
 Result readSeq(struct Slice *tokens)
@@ -89,14 +91,14 @@ Object parseAtom(struct Slice *s)
 
 Object evalDefArgs(const Object *arg_forms, struct Environment *env)
 {
-    const Object *first_form = arg_forms;
+    const Object *newSymbol = arg_forms;
-    const char *name = first_form->name;
+    const char *name = newSymbol->name;
 
-    Object second_eval = eval(first_form->forward, env);
+    const Object newValue = eval(newSymbol->forward, env);
 
-    addToEnv(env, name, second_eval);
+    addToEnv(env, name, newValue);
 
-    return *first_form;
+    return *newSymbol;
 }
 
 Object evalIfArgs(const Object *arg_forms, struct Environment *env)
@@ -118,25 +120,22 @@ Object evalMapArgs(const Object *arg_forms, struct Environment *env)
         return errorObject(NULL_MAP_ARGS);
     
     const Object lambda = eval(arg_forms, env);
-    Object *oldList = arg_forms->forward;
+    const Object *inputList = arg_forms->forward;
 
-    if(lambda.type != TYPE_LAMBDA || oldList->type != TYPE_LIST)
+    if(lambda.type != TYPE_LAMBDA || inputList->type != TYPE_LIST)
         return errorObject(BAD_TYPE);
 
     Object list = listObject();
 
-    const Object *oldElement = oldList->list;
+    FOR_POINTER_IN_LIST(inputList) {
-    while(oldElement != NULL) {
+        // Create a new list for each element,
-        // Create a new list for each element in the list,
         // since lambda evaluation looks for a list
-        const Object tempList = startList(*oldElement);
+        const Object tempList = startList(*POINTER);
 
         struct Environment newEnv = 
                 envForLambda(&lambda.lambda->params, &tempList, env);
-        const Object evalLambda = eval(&lambda.lambda->body, &newEnv);
+        // Add the lambda evaluation to the list
-
+        nf_addToList(&list, eval(&lambda.lambda->body, &newEnv));
-        nf_addToList(&list, evalLambda);
-        oldElement = oldElement->forward;
     }
 
     return list;
@@ -209,6 +208,7 @@ Object eval(const Object *obj, struct Environment *env)
                 for(int i = 1; i < length; i++) {
                     func_eval = first_eval.func(func_eval, rest[i], env);
                 }
+
                 // deleteList(obj); // Decreases indirectly lost memory, but fails on Pebble
                 return func_eval;
 
@@ -216,12 +216,10 @@ Object eval(const Object *obj, struct Environment *env)
                 struct Environment newEnv = 
                         envForLambda(&first_eval.lambda->params, first_form->forward, env);
                 Object ret = eval(&first_eval.lambda->body, &newEnv);
-                //printEnv(&newEnv);
                 deleteEnv(&newEnv);
                 return ret;
 
             } else {
-                // printf("Return list as passed");
                 return *obj;
             }
         }
@@ -229,10 +227,9 @@ Object eval(const Object *obj, struct Environment *env)
             return errorObject(UNEXPECTED_FORM);
 
         default:
-        ;
-    }
             return *obj;
     }
+}
 
 Result result(Object obj, struct Slice *slices)
 {
@@ -295,21 +292,24 @@ Object basicOp(const Object *obj1, const Object *obj2, const char op,
     int lists = (obj1->type == TYPE_LIST) + (obj2->type == TYPE_LIST);
     if(lists == 0) {
         return _basicOp(obj1, obj2, op);
+
     } else if(lists == 1) { // Single operand is applied to each element in list
         const Object *listObj = (obj1->type == TYPE_LIST)? obj1 : obj2;
         const Object *singleObj = (obj1->type == TYPE_LIST)? obj2 : obj1;
+
         Object newList = listObject();
         FOR_POINTER_IN_LIST(listObj) {
             Object adding = eval(POINTER, env);
             nf_addToList(&newList, _basicOp(&adding, singleObj, op));
         }
         return newList;
+
     } else { // 2 lists
         if(listLength(obj1) == listLength(obj2)) {
             Object newList = listObject();
             FOR_POINTERS_IN_LISTS(obj1, obj2) {
-                Object ev1 = eval(P1, env);
+                const Object ev1 = eval(P1, env);
-                Object ev2 = eval(P2, env);
+                const Object ev2 = eval(P2, env);
                 nf_addToList(&newList, _basicOp(&ev1, &ev2, op));
             }
             return newList;
@@ -319,37 +319,39 @@ Object basicOp(const Object *obj1, const Object *obj2, const char op,
     }
 }
 
-#define bopf(_name, _char) \
+#define BASIC_OP(_name, _char) \
 Object _name(Object obj1, Object obj2, struct Environment *env) \
     { return basicOp(&obj1, &obj2, _char, env); }
 
-bopf(add, '+');
+BASIC_OP(add, '+');
-bopf(sub, '-');
+BASIC_OP(sub, '-');
-bopf(mul, '*');
+BASIC_OP(mul, '*');
-bopf(dvi, '/');
+BASIC_OP(dvi, '/');
-bopf(mod, '%');
+BASIC_OP(mod, '%');
-bopf(equ, '=');
+BASIC_OP(equ, '=');
-bopf(gth, '>');
+BASIC_OP(gth, '>');
-bopf(lth, '<');
+BASIC_OP(lth, '<');
 
-#undef bopf
+#undef BASIC_OP
 
 Object parseEval(const char *input, struct Environment *env)
 {
     struct Slice *tokens = nf_tokenize(input);
     if(!tokens)
         return errorObject(MISMATCHED_PARENS);
+
 #ifdef DEBUG
     struct Slice *debug = tokens;
     if(debug) {
         while(debug->text) {
             char tok[MAX_TOK_LEN];
             copySlice(tok, debug);
-            //printd("slice: '%s'\n", tok);
+            printd("slice: '%s'\n", tok);
             debug++;
         }
     }
 #endif
+
     int i = 0;
     int parens = 0;
     Object obj;
@@ -381,8 +383,6 @@ int repl(struct Environment *env)
         fgets(input, 100, stdin);
         Object obj = parseEval(input, env);
         printAndClean(&obj);
-        // printObj(&obj);
-        // printEnv(env);
     }
 }
 
@@ -396,18 +396,9 @@ int main(int argc, const char* argv[])
             r = parseEval(argv[i], &env);
         }
         printObj(&r);
-        // Object r = parseEval(argv[1], &env);
         // printAndClean(&r);
     } else {
-#ifndef NO_REPL
         repl(&env);
-#else
-        Object r = parseEval("(def ad (fn (a) (+ 1 a)))", &env);
-        printAndClean(&r);
-        r = parseEval("(map ad (1 2 3))", &env);
-        printAndClean(&r);
-#endif
     }
-    // deleteEnv(&env);
 }
 #endif