cw/main.c

 TOKEN* lookup_token(char *s);
 int asprintf(char **strp, const char *fmt, ...);
 
+int debug = 0;
+
 /*
  * Existing problems/todo:
  * return from control block, need a "return address" to jump to -- call levels
 }
 
 // forward declare because it is used in add_var_to_env
-int recursive_interpret(NODE*, ENV*);
+BIND* recursive_interpret(NODE*, ENV*);
 
 void print_tree(NODE *tree) {
     print_tree0(tree, 0);
   return a;
 }
 
-void add_args_to_env(NODE *tree, ENV *env_ptr) {
-  if (tree->type == '~') {
-    BIND* arg;
-    TOKEN *tok, *name;
-    // we found an argument
-    name = (TOKEN*)tree->right->left;
-    tok = new_token(INT);
-    tok->value = 0;
-    asprintf(&tok->lexeme, "%d", tok->value);
-    arg = create_binding(name, (NODE*) tok, NULL);
-    if (env_ptr->bindings == NULL) {
-      env_ptr->bindings = create_list(arg, NULL);
-    } else {
-      append_list(env_ptr->bindings, arg);
-    }
-  } else {
-    add_args_to_env(tree->left, env_ptr);
-    add_args_to_env(tree->right, env_ptr);
-  }
-}
-
 void populate_arg_list(NODE *tree, TOKEN** arr, int arr_len) {
   if (tree->type == '~') {
     for (int i = 0; i < arr_len; i++) {
   NODE* func_name = tree->left->right->left->left;
   TOKEN* name_token = (TOKEN*) func_name;
   if ((existing = find_name_in_env(name_token, env_ptr)) == NULL) {
-    ENV* new_func_env = create_new_function_env(env_ptr);
-    if (tree->left->right->right != NULL) {
-      add_args_to_env(tree->left->right->right, new_func_env);
-    }
     if (env_ptr->bindings == NULL) {
-      env_ptr->bindings = create_list(create_binding(name_token, tree, new_func_env), 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, new_func_env));
+      append_list(env_ptr->bindings, create_binding(name_token, tree, env_ptr));
     }
   } else {
     printf("Error: redefinition of function with name %s\n", name_token->lexeme);
   }
 }
 
-void populate_val_list(NODE* tree, TOKEN** arr, int num_args) {
-  if (tree->type == LEAF) {
+void populate_val_list(NODE* tree, NODE** arr, int num_args, ENV* env_ptr) {
+  if (tree->type == ',') {
+    populate_val_list(tree->left, arr, num_args, env_ptr);
+    populate_val_list(tree->right, arr, num_args, env_ptr);
+  } else {
     for (int i = 0; i < num_args; i++) {
       if (arr[i] == NULL) {
-        TOKEN* tok = (TOKEN*) tree->left;
-        arr[i] = tok;
+        arr[i] = tree;
         break;
       }
     }
-  } else {
-    populate_val_list(tree->left, arr, num_args);
-    populate_val_list(tree->right, arr, num_args);
   }
 }
 
-TOKEN** get_val_list(NODE *tree) {
+NODE** get_val_list(NODE *tree, ENV* env_ptr) {
   int num_args = count_args(tree);
-  TOKEN** arr = (TOKEN**) malloc(sizeof(TOKEN*) * num_args);
-  populate_val_list(tree, arr, num_args);
+  NODE** arr = (NODE**) malloc(sizeof(NODE*) * num_args);
+  populate_val_list(tree, arr, num_args, env_ptr);
   return arr;
 }
 
-void bind_arg(TOKEN* val, TOKEN* arg_name, ENV *env_ptr) {
-  BIND* existing = find_name_in_list(arg_name, env_ptr->bindings);
-  if (existing == NULL) {
-    printf("Attempted to bind arg that doesn't exist, the compiler is broken\n");
-    exit(1);
+void bind_arg(NODE* val, TOKEN* arg_name, ENV *env_ptr, ENV* src_env) {
+  BIND* result = recursive_interpret(val, src_env);
+  if(debug)printf("Binding argument: %s\n", arg_name->lexeme);
+  if (env_ptr->bindings == NULL) {
+    env_ptr->bindings = create_list(create_binding(arg_name, result->tree, result->env), NULL);
+  } else {
+    BIND* existing = find_name_in_list(arg_name, env_ptr->bindings);
+    if (existing) {
+      existing->tree = result->tree;
+    } else {
+      append_list(env_ptr->bindings, create_binding(arg_name, result->tree, result->env));
+    }
   }
-  existing->tree = (NODE*) val;
 }
 
 void add_var_to_env(NODE *tree, ENV *env_ptr) {
   BIND* existing;
   NODE* var_name = tree->left->left;
   TOKEN* name_token = (TOKEN*) var_name;
-  TOKEN* tok = new_token(CONSTANT);
-  tok->value = recursive_interpret(tree->right, env_ptr);
-  asprintf(&tok->lexeme, "%d", tok->value);
+  if (debug) printf("assigning %s:\n", name_token->lexeme);
+  BIND* node = recursive_interpret(tree->right, env_ptr);
   if ((existing = find_name_in_env(name_token, env_ptr)) == NULL) {
     if (env_ptr->bindings == NULL) {
-      env_ptr->bindings = create_list(create_binding(name_token, (NODE*) tok, NULL), NULL);
+      env_ptr->bindings = create_list(create_binding(name_token, node->tree, node->env), NULL);
     } else {
-      append_list(env_ptr->bindings, create_binding(name_token, (NODE*) tok, NULL));
+      append_list(env_ptr->bindings, create_binding(name_token, node->tree, node->env));
     }
   } else {
-    existing->tree = (NODE *) tok;
+    existing->tree = node->tree;
   } 
 }
 
-int recursive_interpret(NODE *tree, ENV *env_ptr) {
-  if (tree==NULL) return 0;
+TOKEN* get_int_token(int value) {
+  TOKEN* res;
+  char buffer[20];
+  snprintf(buffer, 20, "%d", value);
+  res = lookup_token(buffer);
+  if (res->type != CONSTANT) res->type = CONSTANT;
+  if (res->value != value) res->value = value;
+  return res;
+}
+
+BIND* anon_binding(NODE *tree) {
+  return create_binding(NULL, tree, NULL);
+}
+
+BIND* ret_val;
+int returning;
+
+BIND* recursive_interpret(NODE *tree, ENV *env_ptr) {
+  if (returning == 1) return NULL;
+  if (tree==NULL) return NULL;
   if (tree->type==LEAF) {
     if (tree->left->type == CONSTANT) {
-      return ((TOKEN *) tree->left)->value;
+      return anon_binding(tree->left);
     } else if (tree->left->type == STRING_LITERAL) {
       printf("Not implemented\n");
       exit(1);
     } else if (tree->left->type == INT || tree->left->type == FUNCTION) {
       // do nothing we dont care about types for now
-      return 0;
+      return NULL;
     } else {
       // an identifier
       TOKEN* tok = (TOKEN *) tree->left;
       BIND* var_bind = find_name_in_env(tok, env_ptr);
+      if (debug) {
+        printf("looking up %s\n", tok->lexeme);
+      }
       if (var_bind == NULL) {
         printf("Could not find variable %s\n", tok->lexeme);
         exit(1);
       }
+      if(debug)printf("I got: ");
       if (var_bind->tree->type == CONSTANT) {
-        TOKEN* var_tok = (TOKEN *) var_bind->tree;
-        return var_tok->value;
+        if(debug){
+          printf("CONSTANT\n");
+          print_leaf(var_bind->tree, 0);
+        }
       } else {
-        printf("Maybe got a function?\n");
-        return 0;
+        if(debug)print_tree(var_bind->tree);
       }
+      return var_bind;
+      /* if (var_bind->tree->type == CONSTANT) { */
+      /*   return var_bind->tree; */
+      /* } else { */
+      /*   print_tree(var_bind->tree); */
+      /*   printf("I GOT A %d from %s\n", var_bind->tree->type, var_bind->name->lexeme); */
+      /*   printf("Maybe got a function?\n"); */
+      /*   return NULL; */
+      /* } */
     }
   }
   if (tree->type=='D') {
     // this is a function definition
     add_function_to_env(tree, env_ptr);
-    return 0;
+    return NULL;
   }
   if (tree->type=='=') {
     // this is a variable definition
     add_var_to_env(tree, env_ptr);
-    return 0;
+    return NULL;
   }
   if (tree->type==APPLY) {
     TOKEN* func_name = ((TOKEN*) tree->left->left);
       printf("Could not find binding for function with name %s\n", func_name->lexeme);
       exit(1);
     }
+    ENV* new_func_env = create_new_function_env(func->env);
+    if (debug) printf("Calling function %s\n", func_name->lexeme);
     if (tree->right != NULL) {
-      TOKEN **arg_list, **val_list;
+      TOKEN **arg_list;
+      NODE **val_list;
       int exp_args, num_args;
       exp_args = count_args(func->tree->left->right->right);
       num_args = count_args(tree->right);
       arg_list = get_argument_list(func->tree);
-      val_list = get_val_list(tree->right);
+      val_list = get_val_list(tree->right, env_ptr);
       if (exp_args == num_args) {
         for (int i = 0; i < num_args; i++) {
-          bind_arg(val_list[i], arg_list[i], func->env);
+          bind_arg(val_list[i], arg_list[i], new_func_env, env_ptr);
         }
       } else {
         printf("Incorrect arguments passed to function %s, expected %d got %d\n", func_name->lexeme, exp_args, num_args);
         exit(1);
       }
     }
-    return recursive_interpret(func->tree->right, func->env);
+    recursive_interpret(func->tree->right, new_func_env);
+    if (returning == 1) {
+      returning = 0;
+      return ret_val;
+    } else {
+      printf("HELP called a function with no return!!\n");
+    }
   }
   if (tree->type == IF) {
-    if (recursive_interpret(tree->left, env_ptr) == 1) {
+    if (((TOKEN*)recursive_interpret(tree->left, env_ptr)->tree)->value == 1) {
       ENV* scope_env = create_new_function_env(env_ptr);
       if (tree->right->type == ELSE) {
         return recursive_interpret(tree->right->left, scope_env);
     }
   }
   if (tree->type == LE_OP) {
-    return (int)recursive_interpret(tree->left, env_ptr) <= recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value <= rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == GE_OP) {
-    return (int)recursive_interpret(tree->left, env_ptr) >= recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value >= rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == EQ_OP) {
-    return (int)recursive_interpret(tree->left, env_ptr) == recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    if (debug) printf("Comparing %d == %d\n", lhs->value, rhs->value);
+    int result = lhs->value == rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == NE_OP) {
-    return (int)recursive_interpret(tree->left, env_ptr) != recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value != rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '>') {
-    return (int)recursive_interpret(tree->left, env_ptr) > recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value > rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '<') {
-    return (int)recursive_interpret(tree->left, env_ptr) < recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value < rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '+') {
-    return recursive_interpret(tree->left, env_ptr) + recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    if (debug) printf("Adding %d and %d\n", lhs->value, rhs->value);
+    int result = lhs->value + rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '-') {
-    return recursive_interpret(tree->left, env_ptr) - recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value - rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '*') {
-    return recursive_interpret(tree->left, env_ptr) * recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value * rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '/') {
-    return recursive_interpret(tree->left, env_ptr) / recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value / rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '%') {
-    return recursive_interpret(tree->left, env_ptr) % recursive_interpret(tree->right, env_ptr);
+    TOKEN* lhs = (TOKEN*) recursive_interpret(tree->left, env_ptr)->tree;
+    TOKEN* rhs = (TOKEN*) recursive_interpret(tree->right, env_ptr)->tree;
+    int result = lhs->value % rhs->value;
+    return anon_binding((NODE*) get_int_token(result));
   }
   if (tree->type == '~') {
     if (tree->left->type == INT || tree->left->type == FUNCTION) {
     }
   }
   if (tree->type == RETURN) {
-    return recursive_interpret(tree->left, env_ptr);
+    ret_val = recursive_interpret(tree->left, env_ptr);
+    returning = 1;
   }
   if (tree->type == WHILE) {
     ENV* scope_env = create_new_function_env(env_ptr);
-    while (recursive_interpret(tree->left, env_ptr)) {
+    while(((TOKEN*)recursive_interpret(tree->left, env_ptr)->tree)->value == 1) {
       recursive_interpret(tree->right, scope_env);
     }
     return 0;
   }
   // print ref_main to make sure we really got it
   printf("Located %s, ready to run!\n", ref_main->name->lexeme);
-  printf("%d\n", recursive_interpret(ref_main->tree->right, ref_main->env));
+  recursive_interpret(ref_main->tree->right, ref_main->env);
+  /* printf("%d\n", ((TOKEN*)recursive_interpret(ref_main->tree->right, ref_main->env))->value); */
+  printf("%d\n", ((TOKEN*)ret_val->tree)->value);
 }
 
 extern int yydebug;
 int main(int argc, char** argv)
 {
     NODE* tree;
-    if (argc>1 && strcmp(argv[1],"-d")==0) yydebug = 1;
+    if (argc>1 && strcmp(argv[1],"-d")==0) debug = 1;
     init_symbtable();
     printf("--C COMPILER\n");
     yyparse();

cw/simple.c

-int sum(int a, int b, int c) {
-  int y = 0;
-  if (a > 2) {
-    int x = 3;
-    y = x;
-  }
-  return y + b + c;
+int whammy(int a) {
+  return a + 5;
 }
 
-int fact(int n) {
-  int inner_fact(int n, int a) {
-    if (n == 0) return a;
-    return inner_fact(n-1, a*n);
-  }
-  return inner_fact(n, 1);
+function twice(function f) {
+  int g(int x) { return f(f(x)); }
+  return g;
 }
 
 int main() {
-  return fact(3);
+  x = twice(whammy);
+
+  return x(2);
 }
+

cw/tests/cond_loop.c

+/* ##answer: 17*/
 int y = 0;
 
 int incr_one() {
   y = y + 1;
+  return 0;
 }
 
 int incr_two() {
   y = y + 2;
+  return 0;
 }
 
 int main() {

cw/tests/cplus.c

+/* ##answer: 29 */
+function cplus(int a) {
+  int cplusa(int b) {
+    return a + b;
+  }
+
+  return cplusa;
+}
+
+int main() {
+  int x = cplus(5);
+  int y = x;
+  int f = cplus(2);
+  int z = y;
+
+  return x(2) + f(2) + y(5) + z(3);
+}

cw/tests/func_args.c

+/* ##answer: 14 */
 int y = 0;
 
 int incr_y(int a, int b) {
   y = 2;
 }
 
-/* int blah2(int a, int b, int c, int d) {} */
-
-/* int blah3(int a) {} */
-
 int main() {
   incr_y(2,3);
   incr_y(4, 5);

cw/tests/func_call.c

+/* ##answer: 8*/
+
 int foo() {
   return 5;
 }

cw/tests/modulo.c

+/* ##answer: 1*/
+int main() {
+  return 5 % 2; 
+}

cw/tests/new_test.sh

+#!/bin/bash
+uname=`uname`
+if [ "$uname" = "Darwin" ]; then
+  date="gdate"
+  readlink="greadlink"
+else
+  date="date"
+  readlink="readlink"
+fi
+start=$($date +%s.%N)
+absdir=$($readlink -f $(dirname $0))
+
+pass="\033[32mPASSED\033[0m"
+fail="\033[31mFAILED\033[0m"
+
+tests=0
+passes=0
+
+for i in $(ls $absdir | grep .\*.c | sort); do
+  answer=`$absdir/../mycc < $absdir/$i | tail -n 1`
+  exp_ans=`grep --color=none "##answer" $absdir/$i | sed 's/[^0-9]\+\([0-9]\+\).\+/\1/g'`
+  echo -n "${i%.*} ... "
+  if [ "$answer" -eq "$exp_ans" ]; then
+    echo -e "$pass"
+    passes=$((passes+1))
+  else
+    echo -e "$fail expected $exp_ans got $answer"
+  fi
+  tests=$((tests+1))
+done
+
+end=$($date +%s.%N)    
+runtime=$(python -c "print(${end} - ${start})")
+
+echo -e "\n$passes/$tests passed in $runtime""s"
+
+exit $((tests-passes))

cw/tests/recursion.c

+/* ##answer: 5166*/
+
+int fact(int n) {
+  int inner_fact(int n, int a) {
+    if (n == 0) return a;
+    return inner_fact(n-1, a*n);
+  }
+  return inner_fact(n, 1);
+}
+
+int main() {
+  int x = fact(3);
+  int y = fact(5);
+  int z = fact(7);
+
+  return x+y+z;
+}

cw/tests/return_only.c

+/* ##answer: 3*/
 int main() {
   return 1 + 2;
 }

cw/tests/sub.c

+/* ##answer: 5 */
+int main() {
+  return 10 - 5;
+}

cw/tests/test.sh

-#/bin/bash
+#!/bin/bash
 uname=`uname`
-if [[ "$uname" -eq "Darwin" ]]; then
+if [ "$uname" = "Darwin" ]; then
   date="gdate"
   readlink="greadlink"
+  wc="gwc"
 else
   date="date"
   readlink="readlink"
+  wc="wc"
 fi
 start=$($date +%s.%N)
 absdir=$($readlink -f $(dirname $0))
-ret_only=`$absdir/../mycc < $absdir/return_only.c | tail -n 1`
-var_maths=`$absdir/../mycc < $absdir/var_maths.c | tail -n 1`
-func_call=`$absdir/../mycc < $absdir/func_call.c | tail -n 1`
-cond_loop=`$absdir/../mycc < $absdir/cond_loop.c | tail -n 1`
-func_args=`$absdir/../mycc < $absdir/func_args.c | tail -n 1`
-
-ret_ans='3'
-var_ans='11'
-func_ans='8'
-args_ans='14'
-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
-if [[ "$func_args" -eq $args_ans ]]; then
-  echo "func_args ..... $pass"
-else
-  echo -n "func_args ..... $fail"
-  echo " expected $args_ans but got $func_args"
-  overall='1'
-fi
+tests=0
+passes=0
+
+num=`ls $absdir | grep .\*.c | $wc -L`
+num=$((num-2))
+fmt=`echo "%-$num""s"`
+for i in $(ls $absdir | grep .\*.c | sort); do
+  answer=`$absdir/../mycc < $absdir/$i | tail -n 1`
+  exp_ans=`grep --color=none "##answer" $absdir/$i | sed 's/[^0-9]\+\([0-9]\+\).\+/\1/g'`
+  printf $fmt "${i%.*}"
+  echo -n " ... "
+  if [ "$answer" -eq "$exp_ans" ]; then
+    echo -e "$pass"
+    passes=$((passes+1))
+  else
+    echo -e "$fail expected $exp_ans got $answer"
+  fi
+  tests=$((tests+1))
+done
 
 end=$($date +%s.%N)    
 runtime=$(python -c "print(${end} - ${start})")
 
-echo "\nCompleted 5 tests in $runtime""s"
+echo -e "\n$passes/$tests passed in $runtime""s"
 
-exit $overall
+exit $((tests-passes))

cw/tests/twice.c

+/* ##answer: 12*/
+int whammy(int a) {
+  return a + 5;
+}
+
+function twice(function f) {
+  int g(int x) { return f(f(x)); }
+  return g;
+}
+
+int main() {
+  x = twice(whammy);
+
+  return x(2);
+}
+

cw/tests/var_maths.c

+/* ##answer: 11*/
 int main() {
   int x = 5;
 

cw/types.h

 
 typedef struct environ {
   BLIST *bindings;
+  NODE *ret_val;
   struct environ *parent;
 } ENV;