Add tests

cw/main.c

 #include "list.h"
 
 TOKEN* lookup_token(char *s);
+int asprintf(char **strp, const char *fmt, ...);
 
 /*
  * Existing problems/todo:
   BIND* existing;
   NODE* func_name = tree->left->right->left->left;
   TOKEN* name_token = (TOKEN*) func_name;
+  if (tree->left->right->right == NULL) {
+    printf("%s has no arguments\n", name_token->lexeme);
+  }
   if ((existing = find_name_in_env(name_token, env_ptr)) == NULL) {
-    printf("Added function name %s to environment with value: \n", name_token->lexeme);
-    print_tree(tree);
+    /* printf("Added function name %s to environment with value: \n", name_token->lexeme); */
+    /* print_tree(tree); */
     if (env_ptr->bindings == NULL) {
       env_ptr->bindings = create_list(create_binding(name_token, tree, env_ptr), NULL);
     } else {
       append_list(env_ptr->bindings, create_binding(name_token, tree, env_ptr));
     }
   } else {
-    printf("Updating function name %s with value: \n", name_token->lexeme);
-    print_tree(tree);
-    existing->tree = tree;
-    existing->env = env_ptr;
+    printf("Error: redefinition of function with name %s\n", name_token->lexeme);
   }
 }
 
   tok->value = recursive_interpret(tree->right, env_ptr);
   asprintf(&tok->lexeme, "%d", tok->value);
   if ((existing = find_name_in_env(name_token, env_ptr)) == NULL) {
-    printf("Added variable name %s to environment with value: %s\n", name_token->lexeme, tok->lexeme);
+    /* printf("Added variable name %s to environment with value: %s\n", name_token->lexeme, tok->lexeme); */
     if (env_ptr->bindings == NULL) {
       env_ptr->bindings = create_list(create_binding(name_token, (NODE*) tok, NULL), NULL);
     } else {
       append_list(env_ptr->bindings, create_binding(name_token, (NODE*) tok, NULL));
     }
   } else {
-    printf("Updating variable name %s with value: %s\n", name_token->lexeme, tok->lexeme);
+    /* printf("Updating variable name %s with value: %s\n", name_token->lexeme, tok->lexeme); */
     existing->tree = (NODE *) tok;
   } 
 }
       printf("Not implemented\n");
       exit(1);
     } else if (tree->left->type == INT || tree->left->type == FUNCTION) {
-      // do nothing we dont care about types
+      // do nothing we dont care about types for now
       return 0;
     } else {
       // an identifier
   if (tree->type == RETURN) {
     return recursive_interpret(tree->left, env_ptr);
   }
+  if (tree->type == WHILE) {
+    while (recursive_interpret(tree->left, env_ptr)) {
+      recursive_interpret(tree->right, env_ptr);
+    }
+    return 0;
+  }
   recursive_interpret(tree->left, env_ptr);
   return recursive_interpret(tree->right, env_ptr);
 }

cw/simple.c

-int main() {
+int y = 0;
+
+int incr_y(int a) {
+  y = y + 2;
+}
 
-  int foo = 1 + 4;
-  int bar = 2 + foo;
+int blah() {
+}
+
+int main() {
 
-  int baz = foo + bar;
+  int x = 0;
+  while (x < 10) {
+    incr_y();
+    x = x + 1;
+  }
 
-  return baz;
+  return y;
 }

cw/tests/cond_loop.c

+int y = 0;
+
+int incr_one() {
+  y = y + 1;
+}
+
+int incr_two() {
+  y = y + 2;
+}
+
+int main() {
+
+  int x = 0;
+
+  while (x <= 10) {
+    if (y < 5) {
+      incr_one();
+    } else {
+      incr_two();
+    }
+    x = x + 1;
+  }
+  
+  return y;
+}

cw/tests/func_call.c

+int foo() {
+  return 5;
+}
+
+int main() {
+  int x = foo() + 3;
+
+  return x % 17;
+}

cw/tests/return_only.c

+int main() {
+  return 1 + 2;
+}

cw/tests/test.sh

+#/bin/bash
+ret_only=`../mycc < ./return_only.c | tail -n 1`
+var_maths=`../mycc < ./var_maths.c | tail -n 1`
+func_call=`../mycc < ./func_call.c | tail -n 1`
+cond_loop=`../mycc < ./cond_loop.c | tail -n 1`
+
+ret_ans='3'
+var_ans='11'
+func_ans='8'
+cond_ans='17'
+
+overall='0'
+
+pass="\033[32mPASSED\033[0m"
+fail="\033[31mFAILED\033[0m"
+
+if [ "$ret_only" -eq $ret_ans ]; then
+  echo "return_only ... $pass"
+else
+  echo -n "return_only ... $fail"
+  echo " expected $ret_ans but got $ret_only"
+  overall='1'
+fi
+if [ "$var_maths" -eq $var_ans ]; then
+  echo "var_maths ..... $pass"
+else
+  echo "var_maths ..... $fail"
+  echo " expected $var_ans but got $var_maths"
+  overall='1'
+fi
+if [ "$func_call" -eq $func_ans ]; then
+  echo "func_call ..... $pass"
+else
+  echo -n "func_call ..... $fail"
+  echo " expected $func_ans but got $func_call"
+  overall='1'
+fi
+if [ "$cond_loop" -eq $cond_ans ]; then
+  echo "cond_loop ..... $pass"
+else
+  echo -n "cond_loop ..... $fail"
+  echo " expected $cond_ans but got $cond_loop"
+  overall='1'
+fi
+
+exit $overall

cw/tests/var_maths.c

+int main() {
+  int x = 5;
+
+  return x + 3 * 2;
+}