woo

tac/README.md

@@ -1,3 +0,0 @@
-# mips-c-compiler
-
-A MIPS compiler for a subset of C that includes closures, for 3rd year compilers coursework

tac/finaltest1.tac

@@ -1,205 +0,0 @@
---C COMPILER
-int inner_fact(int n, int a) {
-  if (n==0) {
-    return a;
-  }
-  return inner_fact(n-1,a*n);
-}
-
-int fact(int n) {
-	return inner_fact(n,1);
-}
-
-int main(){
-	return fact(6);
-}
-parse finished
-~
-  ~
-    D
-      d
-        int
-        F
-          inner_fact
-          ,
-            ~
-              int
-              n
-            ~
-              int
-              a
-      ;
-        if
-          ==
-            n
-            0
-          return
-            a
-        return
-          apply
-            inner_fact
-            ,
-              -
-                n
-                1
-              *
-                a
-                n
-    D
-      d
-        int
-        F
-          fact
-          ~
-            int
-            n
-      return
-        apply
-          inner_fact
-          ,
-            n
-            1
-  D
-    d
-      int
-      F
-        main
-    return
-      apply
-        fact
-        6
-func inner_fact
-param n
-param a
-if n != 0 then L0
-ret a
-L0
-$t1 := n - 1
-$t2 := a * n
-arg $t1
-arg $t2
-call inner_fact, $t0
-ret $t0
-end inner_fact
-
-func fact
-param n
-arg n
-arg 1
-call inner_fact, $t3
-ret $t3
-end fact
-
-func main
-arg 6
-call fact, $t4
-ret $t4
-end main
-
-=====
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-jal main
-j done
-#func inner_fact
-inner_fact:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, inner_fact
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#param n
-or $16, $0, $5
-#param a
-or $17, $0, $6
-#if n != 0 then L0
-bne $16, $0, L0
-#ret a
-or $v1, $0, $17
-jr $31
-#L0
-L0:
-#$t1 := n - 1
-li $9, 1
-sub $8, $16, $9
-#$t2 := a * n
-mult $17, $16
-mflo $10
-#arg $t1
-or $5, $0, $8
-#arg $t2
-or $6, $0, $10
-#call inner_fact, $t0
-jal inner_fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $11, $0, $v1
-#ret $t0
-or $v1, $0, $11
-jr $31
-#end inner_fact
-
-#func fact
-fact:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, fact
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#param n
-or $16, $0, $5
-#arg n
-or $5, $0, $16
-#arg 1
-li $12, 1
-or $6, $0, $12
-#call inner_fact, $t3
-jal inner_fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-or $13, $0, $v1
-#ret $t3
-or $v1, $0, $13
-jr $31
-#end fact
-
-#func main
-main:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#arg 6
-li $14, 6
-or $5, $0, $14
-#call fact, $t4
-jal fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-or $15, $0, $v1
-#ret $t4
-or $v1, $0, $15
-jr $31
-#end main
-
-done:
-ori $v0, $0, 10
-syscall

tac/main.c

@@ -123,7 +123,8 @@ char* stok(TOKEN* tok) {
 
 void print_tac_el(TAC_T* elem) {
     int op = elem->op;
-    if (op == '=') printf("%s := %s\n", stok(elem->dst), stok(elem->src));
+    if (op == '=' && elem->tgt == NULL) printf("%s := %s\n", stok(elem->dst), stok(elem->src));
+    if (op == '=' && elem->tgt != NULL) printf("%s: %s := %s\n", stok(elem->tgt), stok(elem->dst), stok(elem->src));
     if (op=='+' || op=='-' || op=='*' || op=='/' || op =='%') printf("%s := %s %c %s\n", stok(elem->dst), stok(elem->src), op, stok(elem->tgt));
     if (op == RETURN) printf("ret %s\n", stok(elem->src));
     if (op == 'D') printf("func %s\n", stok(elem->dst));
@@ -230,6 +231,18 @@ TOKEN* build_tac(NODE *tree, TACS* tac, TACS* after_tac) {
   int type = tree->type;
   if (type == LEAF) {
     return (TOKEN *) tree->left;
+  } else if (type == '~') {
+    if (tree->right->type == '=') {
+      NODE *vtree = tree->right;
+      TOKEN* dst = (TOKEN*) vtree->left->left;
+      TOKEN* result = build_tac(vtree->right, tac, after_tac);
+      TOKEN* def = lookup_token("def");
+      new_tac(tac, dst, result, def, vtree->type);
+    } else {
+      build_tac(tree->left, tac, after_tac);
+      build_tac(tree->right, tac, after_tac);
+      return NULL;
+    }
   } else if (type == '=') {
     TOKEN* dst = (TOKEN*) tree->left->left;
     TOKEN* result = build_tac(tree->right, tac, after_tac);
@@ -321,11 +334,22 @@ int register_me(TOKEN* name, ENV* env) {
     if (binding == NULL) {
       BIND* new_bind;
       if (name->lexeme[0] != '$') {
-        new_bind = create_binding(name, env->counter++, NULL);
-        if (env->bindings == NULL) env->bindings = create_list(new_bind, NULL);
-        else append_list(env->bindings, new_bind);
-        new_bind->is_saved = 1;
-        return svd_regs[new_bind->env_offset];
+        int levels = 0;
+        ENV* env_ptr = env->parent;
+        printf("or $k0, $fp, $0\n");
+        while (env_ptr != NULL) {
+          printf("lw $fp, 68($fp)\n");
+          levels++;
+          BIND *binding = find_name_in_list(name, env_ptr->bindings);
+          if (binding != NULL) {
+            printf("lw $%d, %d($fp)\n", tmp_regs[tmp_cntr], binding->env_offset);
+            printf("or $fp, $k0, $0\n");
+            return tmp_regs[tmp_cntr++];
+          }
+          env_ptr = env_ptr->parent;
+        }
+        printf("%s not defined in scope\n", name->lexeme);
+        exit(1);
       } else {
         new_bind = create_binding(name, tmp_cntr++, NULL);
         if (env->bindings == NULL) env->bindings = create_list(new_bind, NULL);
@@ -338,15 +362,55 @@ int register_me(TOKEN* name, ENV* env) {
   }
 }
 
+int def_register_me(TOKEN* name, ENV* env) {
+  BIND* binding = find_name_in_list(name, env->bindings);
+  if (binding == NULL) {
+    BIND* new_bind;
+    new_bind = create_binding(name, env->counter++, NULL);
+    if (env->bindings == NULL) env->bindings = create_list(new_bind, NULL);
+    else append_list(env->bindings, new_bind);
+    new_bind->is_saved = 1;
+    return svd_regs[new_bind->env_offset];
+  } else {
+    printf("Error, %s redefined in scope.\n", name->lexeme);
+    exit(1);
+  }
+}
+
+void add_closure(TOKEN* name, ENV* env) {
+  BIND* binding = find_name_in_list(name, env->bindings);
+  if (binding == NULL) {
+    BIND* new_bind;
+    new_bind =create_binding(name, 0, env);
+    if (env->bindings == NULL) env->bindings = create_list(new_bind, NULL);
+    else append_list(env->bindings, new_bind);
+  } else {
+    printf("Error, %s redefined in scope.\n", name->lexeme);
+    exit(1);
+  }
+}
+
+ENV* find_closure_env(TOKEN* name, ENV* env) {
+  BIND* binding = find_name_in_list(name, env->bindings);
+  if (binding == NULL) {
+    return NULL;
+  } else {
+    return binding->env;
+  }
+}
+
 void alloc_function_env() {
-  printf("li $a0, 68\n");
+  printf("li $a0, 72\n");
   printf("li $v0, 9\n");
   printf("syscall\n");
 }
 
 void compile_tac(TLIST* tacs) {
   ENV* env = create_new_function_env(NULL, NULL);
+  ENV* closure_tab = create_new_function_env(NULL, NULL);
   printf("=====\n");
+  printf(".globl __start\n");
+  printf("__start:\n");
   alloc_function_env();
   printf("or $fp, $0, $v0\n");
   printf("la $t0, main\n");
@@ -361,24 +425,31 @@ void compile_tac(TLIST* tacs) {
       print_tac_el(t);
     }
     if (t->op == '=') {
+      int dst;
+      if (t->tgt == NULL) {
+        dst = register_me(t->dst, env);
+      } else {
+        dst = def_register_me(t->dst, env);
+      }
       int src = register_me(t->src, env);
-      int dst = register_me(t->dst, env);
       printf("or $%d, $0, $%d\n", dst, src);
     }
     if (t->op == 'D') {
-      env = create_new_function_env(NULL, env);
+      ENV* closure_env;
+      int i = 2;
+      int j;
+      if ((closure_env = find_closure_env(t->dst, closure_tab)) == NULL) {
+        env = create_new_function_env(env, env);
+      } else {
+        env = create_new_function_env(closure_env, env);
+      }
       printf("%s:\n", t->dst->lexeme);
       alloc_function_env();
       printf("sw $fp, 4($v0)\n");
-      if (env->previous->bindings != NULL) {
-        int i = 2;
-        BLIST* ptr = env->previous->bindings;
-        while (ptr != NULL) {
-          if (ptr->binding->name->lexeme[0] != '$') {
-            printf("sw $%d, %d($fp)\n", svd_regs[ptr->binding->env_offset], i*4);
-            i++;
-          }
-          ptr = ptr->next;
+      if (t->dst != lookup_token("main")) {
+        for (j = 0; j < 8; j++) {
+          printf("sw $%d, %d($fp)\n", svd_regs[j], i*4);
+          i++;
         }
       }
       printf("or $fp, $0, $v0\n");
@@ -487,14 +558,29 @@ void compile_tac(TLIST* tacs) {
       printf("or $%d, $0, $%d\n", arg_regs[env->arg_counter], dst_idx);
       env->arg_counter++;
     }
+    if (t->op == 280) {
+      int dst_idx = def_register_me(t->dst, env);
+      add_closure(t->dst, closure_tab);
+      alloc_function_env();
+      printf("or $%d, $v0, $0\n", dst_idx);
+      printf("la $v0, %s\n", t->dst->lexeme);
+      printf("sw $v0, 0($%d)\n", dst_idx);
+      printf("sw $fp, 68($%d)\n", dst_idx);
+    }
     if (t->op == AUTO) {
-      int dst_idx = register_me(t->dst, env);
+      int dst_idx = def_register_me(t->dst, env);
       printf("or $%d, $0, $%d\n", dst_idx, arg_regs[env->param_counter]);
       env->param_counter++;
     }
     tacs = tacs->next;
   }
   printf("done:\n");
+  printf("or $a0, $v1, $0\n");
+  printf("ori $v0, $0, 1\n");
+  printf("syscall\n");
+  printf("ori $a0, $0, 0xA\n");
+  printf("ori $v0, $0, 0xB\n");
+  printf("syscall\n");
   printf("ori $v0, $0, 10\n");
   printf("syscall\n");
 }

tac/mips.asm

@@ -1,54 +0,0 @@
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-la $ra, done
-j main
-blah:
-sw $ra, 64($fp)
-or $16, $0, $5
-li $8, 3
-or $17, $0, $8
-add $9, $17, $16
-or $v1, $0, $9
-jr $31
-main:
-sw $ra, 64($fp)
-li $10, 4
-or $16, $0, $10
-li $11, 4
-or $5, $0, $11
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-or $fp, $0, $v0
-la $t0, blah
-sw $t0, 0($fp)
-jal blah
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-or $12, $0, $v1
-or $17, $0, $12
-li $13, 5
-ble $17, $13, L0
-li $15, 10
-add $14, $16, $15
-or $16, $0, $14
-j L1
-L0:
-li $25, 5
-add $24, $16, $25
-or $16, $0, $24
-L1:
-add $8, $17, $16
-or $v1, $0, $8
-jr $31
-done:
-ori $v0, $0, 10
-syscall

tac/recurse.asm

@@ -1,155 +0,0 @@
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-la $ra, done
-j main
-#func inner_fact
-inner_fact:
-sw $ra, 64($fp)
-#param n
-or $16, $0, $5
-#param a
-or $17, $0, $6
-#if n != 0 then L0
-bne $16, $0, L0
-#ret a
-or $v1, $0, $17
-jr $31
-#L0
-L0:
-#$t1 := n - 1
-li $9, 1
-sub $8, $16, $9
-#$t2 := a * n
-mult $17, $16
-mflo $10
-#arg $t1
-or $5, $0, $8
-#arg $t2
-or $6, $0, $10
-#call inner_fact, $t0
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-sw $17, 12($fp)
-or $fp, $0, $v0
-la $t0, inner_fact
-sw $t0, 0($fp)
-jal inner_fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $11, $0, $v1
-#ret $t0
-or $v1, $0, $11
-jr $31
-#end inner_fact
-
-#func fact
-fact:
-sw $ra, 64($fp)
-#param n
-or $16, $0, $5
-#arg n
-or $5, $0, $16
-#arg 1
-li $12, 1
-or $6, $0, $12
-#call inner_fact, $t3
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-or $fp, $0, $v0
-la $t0, inner_fact
-sw $t0, 0($fp)
-jal inner_fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-or $13, $0, $v1
-#ret $t3
-or $v1, $0, $13
-jr $31
-#end fact
-
-#func main
-main:
-sw $ra, 64($fp)
-#arg 3
-li $14, 3
-or $5, $0, $14
-#call fact, $t4
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, fact
-sw $t0, 0($fp)
-jal fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-or $15, $0, $v1
-#x := $t4
-or $16, $0, $15
-#arg 5
-li $24, 5
-or $5, $0, $24
-#call fact, $t5
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-or $fp, $0, $v0
-la $t0, fact
-sw $t0, 0($fp)
-jal fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-or $25, $0, $v1
-#y := $t5
-or $17, $0, $25
-#arg 7
-li $8, 7
-or $5, $0, $8
-#call fact, $t6
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-sw $17, 12($fp)
-or $fp, $0, $v0
-la $t0, fact
-sw $t0, 0($fp)
-jal fact
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $9, $0, $v1
-#z := $t6
-or $18, $0, $9
-#$t8 := x + y
-add $10, $16, $17
-#$t7 := $t8 + z
-add $11, $10, $18
-#ret $t7
-or $v1, $0, $11
-jr $31
-#end main
-
-done:
-ori $v0, $0, 10
-syscall

tac/test.asm

@@ -1,3 +1,5 @@
+.globl __start
+__start:
 li $a0, 68
 li $v0, 9
 syscall
@@ -5,71 +7,84 @@ or $fp, $0, $v0
 la $t0, main
 sw $t0, 0($fp)
 sw $0, 4($fp)
-la $ra, done
-j main
-inner_fact:
-sw $ra, 64($fp)
-or $16, $0, $5
-or $17, $0, $6
-bne $16, $0, L0
-or $v1, $0, $17
-jr $31
-L0:
-li $9, 1
-sub $8, $16, $9
-mult $17, $16
-mflo $10
-or $5, $0, $8
-or $6, $0, $10
+jal main
+j done
+fact:
 li $a0, 68
 li $v0, 9
 syscall
 sw $fp, 4($v0)
 sw $16, 8($fp)
 sw $17, 12($fp)
+sw $18, 16($fp)
+sw $19, 20($fp)
+sw $20, 24($fp)
+sw $21, 28($fp)
+sw $22, 32($fp)
+sw $23, 36($fp)
 or $fp, $0, $v0
-la $t0, inner_fact
+la $t0, fact
 sw $t0, 0($fp)
+sw $ra, 64($fp)
+or $16, $0, $5
+or $5, $0, $16
+li $8, 1
+or $6, $0, $8
 jal inner_fact
 lw $fp, 4($fp)
 lw $ra, 64($fp)
 lw $16, 8($fp)
-lw $17, 12($fp)
-or $11, $0, $v1
-or $v1, $0, $11
+or $9, $0, $v1
+or $v1, $0, $9
 jr $31
-fact:
-sw $ra, 64($fp)
-or $16, $0, $5
-or $5, $0, $16
-li $12, 1
-or $6, $0, $12
+inner_fact:
 li $a0, 68
 li $v0, 9
 syscall
 sw $fp, 4($v0)
 sw $16, 8($fp)
+sw $17, 12($fp)
+sw $18, 16($fp)
+sw $19, 20($fp)
+sw $20, 24($fp)
+sw $21, 28($fp)
+sw $22, 32($fp)
+sw $23, 36($fp)
 or $fp, $0, $v0
 la $t0, inner_fact
 sw $t0, 0($fp)
+sw $ra, 64($fp)
+or $16, $0, $5
+or $17, $0, $6
+bne $16, $0, L0
+or $v1, $0, $17
+jr $31
+L0:
+li $11, 1
+sub $10, $16, $11
+mult $17, $16
+mflo $12
+or $5, $0, $10
+or $6, $0, $12
 jal inner_fact
 lw $fp, 4($fp)
 lw $ra, 64($fp)
 lw $16, 8($fp)
+lw $17, 12($fp)
 or $13, $0, $v1
 or $v1, $0, $13
 jr $31
 main:
-sw $ra, 64($fp)
-li $14, 3
-or $5, $0, $14
 li $a0, 68
 li $v0, 9
 syscall
 sw $fp, 4($v0)
 or $fp, $0, $v0
-la $t0, fact
+la $t0, main
 sw $t0, 0($fp)
+sw $ra, 64($fp)
+li $14, 3
+or $5, $0, $14
 jal fact
 lw $fp, 4($fp)
 lw $ra, 64($fp)
@@ -77,14 +92,6 @@ or $15, $0, $v1
 or $16, $0, $15
 li $24, 5
 or $5, $0, $24
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-or $fp, $0, $v0
-la $t0, fact
-sw $t0, 0($fp)
 jal fact
 lw $fp, 4($fp)
 lw $ra, 64($fp)
@@ -93,15 +100,6 @@ or $25, $0, $v1
 or $17, $0, $25
 li $8, 7
 or $5, $0, $8
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-sw $17, 12($fp)
-or $fp, $0, $v0
-la $t0, fact
-sw $t0, 0($fp)
 jal fact
 lw $fp, 4($fp)
 lw $ra, 64($fp)
@@ -114,5 +112,11 @@ add $11, $10, $18
 or $v1, $0, $11
 jr $31
 done:
+or $a0, $v1, $0
+ori $v0, $0, 1
+syscall
+ori $a0, $0, 0xA
+ori $v0, $0, 0xB
+syscall
 ori $v0, $0, 10
 syscall

tac/recursion.c

@@ -1,12 +1,9 @@
 /* ##answer: 5166*/
-
-
-int inner_fact(int n, int a) {
-  if (n == 0) return a;
-  return inner_fact(n-1, a*n);
-}
-
 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);
 }
 

tac/simple.c

@@ -1,10 +1,9 @@
-int blah() {
-  int blah2() {
-    return 2;
+int main() {
+  int x = 1;
+  int blah(int b) {
+    return x + b;
   }
-  return blah2();
-}
+  x = 2;
 
-int main() {
-  return blah();
+  return blah(2);
 }

tac/test10.tac

@@ -1,156 +0,0 @@
---C COMPILER
-int main() { 
-int x = 4;
-int y = 5;
-int z = 6;
-int a = x + y;
-int b = y + z;
-int c = z * a;
-int d = b * c;
-int e = x;
-
-return e * d;
-}
-parse finished
-D
-  d
-    int
-    F
-      main
-  ;
-    ;
-      ;
-        ;
-          ;
-            ;
-              ;
-                ;
-                  ~
-                    int
-                    =
-                      x
-                      4
-                  ~
-                    int
-                    =
-                      y
-                      5
-                ~
-                  int
-                  =
-                    z
-                    6
-              ~
-                int
-                =
-                  a
-                  +
-                    x
-                    y
-            ~
-              int
-              =
-                b
-                +
-                  y
-                  z
-          ~
-            int
-            =
-              c
-              *
-                z
-                a
-        ~
-          int
-          =
-            d
-            *
-              b
-              c
-      ~
-        int
-        =
-          e
-          x
-    return
-      *
-        e
-        d
-func main
-x := 4
-y := 5
-z := 6
-$t0 := x + y
-a := $t0
-$t1 := y + z
-b := $t1
-$t2 := z * a
-c := $t2
-$t3 := b * c
-d := $t3
-e := x
-$t4 := e * d
-ret $t4
-end main
-
-=====
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-jal main
-j done
-#func main
-main:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#x := 4
-li $8, 4
-or $16, $0, $8
-#y := 5
-li $9, 5
-or $17, $0, $9
-#z := 6
-li $10, 6
-or $18, $0, $10
-#$t0 := x + y
-add $11, $16, $17
-#a := $t0
-or $19, $0, $11
-#$t1 := y + z
-add $12, $17, $18
-#b := $t1
-or $20, $0, $12
-#$t2 := z * a
-mult $18, $19
-mflo $13
-#c := $t2
-or $21, $0, $13
-#$t3 := b * c
-mult $20, $21
-mflo $14
-#d := $t3
-or $22, $0, $14
-#e := x
-or $23, $0, $16
-#$t4 := e * d
-mult $23, $22
-mflo $15
-#ret $t4
-or $v1, $0, $15
-jr $31
-#end main
-
-done:
-ori $v0, $0, 10
-syscall

tac/test15.tac

@@ -1,133 +0,0 @@
---C COMPILER
-int y = 5;
-
-int fun1(){
-	int x = 11;
-	return x;
-}
-
-
-int main() { 
-	int x = 4;
-	return y * x * fun1();
-}
-parse finished
-~
-  ~
-    ~
-      int
-      =
-        y
-        5
-    D
-      d
-        int
-        F
-          fun1
-      ;
-        ~
-          int
-          =
-            x
-            11
-        return
-          x
-  D
-    d
-      int
-      F
-        main
-    ;
-      ~
-        int
-        =
-          x
-          4
-      return
-        *
-          *
-            y
-            x
-          apply
-            fun1
-y := 5
-func fun1
-x := 11
-ret x
-end fun1
-
-func main
-x := 4
-$t1 := y * x
-call fun1, $t2
-$t0 := $t1 * $t2
-ret $t0
-end main
-
-=====
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-jal main
-j done
-#y := 5
-li $8, 5
-or $16, $0, $8
-#func fun1
-fun1:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-or $fp, $0, $v0
-la $t0, fun1
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#x := 11
-li $9, 11
-or $16, $0, $9
-#ret x
-or $v1, $0, $16
-jr $31
-#end fun1
-
-#func main
-main:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-sw $16, 8($fp)
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#x := 4
-li $10, 4
-or $16, $0, $10
-#$t1 := y * x
-mult $17, $16
-mflo $11
-#call fun1, $t2
-jal fun1
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $12, $0, $v1
-#$t0 := $t1 * $t2
-mult $11, $12
-mflo $13
-#ret $t0
-or $v1, $0, $13
-jr $31
-#end main
-
-done:
-ori $v0, $0, 10
-syscall

tac/test26.tac

@@ -1,321 +0,0 @@
---C COMPILER
-int biggerIsOdd(int x, int y){
-	if(x>y){
-		return isOdd(x);
-	} else {
-		return isOdd(y);
-	}
-}
-
-int isOdd(int x){
-	if(x == 1){
-		return 1;
-	} else {
-		if(isOdd(x-1) == 1){
-			return 0;
-		} else {
-			return 1;
-		}
-	}
-}
-
-
-int main() { 
-	int x = 5;
-	int y = 7;
-
-	if(biggerIsOdd(x,y) == 1){
-		return 400;
-	}
-
-		return 66;
-	
-}
-parse finished
-~
-  ~
-    D
-      d
-        int
-        F
-          biggerIsOdd
-          ,
-            ~
-              int
-              x
-            ~
-              int
-              y
-      if
-        >
-          x
-          y
-        else
-          return
-            apply
-              isOdd
-              x
-          return
-            apply
-              isOdd
-              y
-    D
-      d
-        int
-        F
-          isOdd
-          ~
-            int
-            x
-      if
-        ==
-          x
-          1
-        else
-          return
-            1
-          if
-            ==
-              apply
-                isOdd
-                -
-                  x
-                  1
-              1
-            else
-              return
-                0
-              return
-                1
-  D
-    d
-      int
-      F
-        main
-    ;
-      ;
-        ~
-          int
-          =
-            x
-            5
-        ~
-          int
-          =
-            y
-            7
-      ;
-        if
-          ==
-            apply
-              biggerIsOdd
-              ,
-                x
-                y
-            1
-          return
-            400
-        return
-          66
-func biggerIsOdd
-param x
-param y
-if x <= y then L0
-arg x
-call isOdd, $t0
-ret $t0
-goto L1
-L0
-arg y
-call isOdd, $t1
-ret $t1
-L1
-end biggerIsOdd
-
-func isOdd
-param x
-if x != 1 then L2
-ret 1
-goto L3
-L2
-$t3 := x - 1
-arg $t3
-call isOdd, $t2
-if $t2 != 1 then L4
-ret 0
-goto L5
-L4
-ret 1
-L5
-L3
-end isOdd
-
-func main
-x := 5
-y := 7
-arg x
-arg y
-call biggerIsOdd, $t4
-if $t4 != 1 then L6
-ret 400
-L6
-ret 66
-end main
-
-=====
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-jal main
-j done
-#func biggerIsOdd
-biggerIsOdd:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, biggerIsOdd
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#param x
-or $16, $0, $5
-#param y
-or $17, $0, $6
-#if x <= y then L0
-ble $16, $17, L0
-#arg x
-or $5, $0, $16
-#call isOdd, $t0
-jal isOdd
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $8, $0, $v1
-#ret $t0
-or $v1, $0, $8
-jr $31
-#goto L1
-j L1
-#L0
-L0:
-#arg y
-or $5, $0, $17
-#call isOdd, $t1
-jal isOdd
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $9, $0, $v1
-#ret $t1
-or $v1, $0, $9
-jr $31
-#L1
-L1:
-#end biggerIsOdd
-
-#func isOdd
-isOdd:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, isOdd
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#param x
-or $16, $0, $5
-#if x != 1 then L2
-li $10, 1
-bne $16, $10, L2
-#ret 1
-li $11, 1
-or $v1, $0, $11
-jr $31
-#goto L3
-j L3
-#L2
-L2:
-#$t3 := x - 1
-li $13, 1
-sub $12, $16, $13
-#arg $t3
-or $5, $0, $12
-#call isOdd, $t2
-jal isOdd
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-or $14, $0, $v1
-#if $t2 != 1 then L4
-li $15, 1
-bne $14, $15, L4
-#ret 0
-or $v1, $0, $0
-jr $31
-#goto L5
-j L5
-#L4
-L4:
-#ret 1
-li $24, 1
-or $v1, $0, $24
-jr $31
-#L5
-L5:
-#L3
-L3:
-#end isOdd
-
-#func main
-main:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-#x := 5
-li $25, 5
-or $16, $0, $25
-#y := 7
-li $8, 7
-or $17, $0, $8
-#arg x
-or $5, $0, $16
-#arg y
-or $6, $0, $17
-#call biggerIsOdd, $t4
-jal biggerIsOdd
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-lw $16, 8($fp)
-lw $17, 12($fp)
-or $9, $0, $v1
-#if $t4 != 1 then L6
-li $10, 1
-bne $9, $10, L6
-#ret 400
-li $11, 400
-or $v1, $0, $11
-jr $31
-#L6
-L6:
-#ret 66
-li $12, 66
-or $v1, $0, $12
-jr $31
-#end main
-
-done:
-ori $v0, $0, 10
-syscall

tac/tests/Makefile

@@ -0,0 +1,9 @@
+OUT:=$(patsubst %.c, %.asm, $(wildcard *.c))
+
+all: $(OUT)
+
+%.asm: %.c
+	../mycc < $< | sed -n '/^=\{5\}$$/ { s///; :a; n; p; ba; }' > $@
+
+clean:
+	rm -rf *.asm

tac/tests/all_scopes.c

@@ -0,0 +1,13 @@
+/* ##answer: 220 */
+int y = 5;
+
+int fun1(){
+	int x = 11;
+	return x;
+}
+
+
+int main() { 
+	int x = 4;
+	return y * x * fun1();
+}

tac/tests/cplus.c

@@ -0,0 +1,17 @@
+/* ##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);
+}

tac/tests/deep_closure.c

@@ -0,0 +1,14 @@
+/* ##answer: 18 */
+function cplus(int a) {
+  int cplusa(int b) {
+    int cplusab(int c) {
+      return a + b + c;
+    }
+    return cplusab;
+  }
+  return cplusa;
+}
+
+int main() {
+  return cplus(5)(6)(7);
+}

tac/tests/func_args.c

@@ -0,0 +1,9 @@
+/* ##answer: 14 */
+int aplusb(int a, int b) {
+  return a + b;
+}
+
+int main() {
+  int y = aplusb(aplusb(2, 3), aplusb(4, 5));
+  return y;
+}

tac/tests/func_call.c

@@ -0,0 +1,11 @@
+/* ##answer: 8*/
+
+int foo() {
+  return 5;
+}
+
+int main() {
+  int x = foo() + 3;
+
+  return x % 17;
+}

tac/tests/immed_call.c

@@ -0,0 +1,11 @@
+/* ##answer: 11 */
+function cplus(int a) {
+  int cplusa(int b) {
+    return a + b;
+  }
+  return cplusa;
+}
+
+int main() {
+  return cplus(5)(6);
+}

tac/tests/modulo.c

@@ -0,0 +1,4 @@
+/* ##answer: 1*/
+int main() {
+  return 5 % 2; 
+}

tac/tests/odd_recursion.c

@@ -0,0 +1,31 @@
+/* ##answer: 400 */
+int biggerIsOdd(int x, int y){
+  if(x>y){
+    return isOdd(x);
+  } else {
+    return isOdd(y);
+  }
+}
+
+int isOdd(int x){
+  if(x == 1){
+    return 1;
+  } else {
+    if(isOdd(x-1) == 1){
+      return 0;
+    } else {
+      return 1;
+    }
+  }
+}
+
+
+int main() { 
+  int x = 5;
+  int y = 7;
+
+  if(biggerIsOdd(x,y) == 1){
+    return 400;
+  }
+  return 66;
+}

tac/tests/really_deep_closure.c

@@ -0,0 +1,20 @@
+/* ##answer: 15 */
+function cplus(int a) {
+  int cplusa(int b) {
+    int cplusab(int c) {
+      int cplusabc(int d) {
+        int cplusabcd(int e) {
+          return a+b+c+d+e;
+        }
+        return cplusabcd;
+      }
+      return cplusabc;
+    }
+    return cplusab;
+  }
+  return cplusa;
+}
+
+int main() {
+  return cplus(1)(2)(3)(4)(5);
+}

tac/tests/recursion.c

@@ -0,0 +1,16 @@
+/* ##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;
+}

tac/tests/return_only.c

@@ -0,0 +1,4 @@
+/* ##answer: 3*/
+int main() {
+  return 1 + 2;
+}

tac/tests/sub.c

@@ -0,0 +1,4 @@
+/* ##answer: 5 */
+int main() {
+  return 10 - 5;
+}

tac/tests/test.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+uname=`uname`
+if [ "$uname" = "Darwin" ]; then
+  date="gdate"
+  readlink="greadlink"
+  wc="gwc"
+  sed="gsed"
+  awk="gawk"
+else
+  date="date"
+  readlink="readlink"
+  wc="wc"
+  sed="sed"
+  awk="awk"
+fi
+start=$($date +%s.%N)
+absdir=$($readlink -f $(dirname $0))
+pass="\033[32mPASSED\033[0m"
+fail="\033[31mFAILED\033[0m"
+tests=0
+passes=0
+num=`find * -name '*.c' | $wc -L`
+num=$((num-2))
+fmt=`echo "%-$num""s"`
+make > /dev/null
+for i in $(find * -name '*.c' | sort); do
+  asm=${i/.c/.asm}
+  answer=`spim -noexception load $absdir/$asm 2> /dev/null | tail -n 1`
+  exp_ans=`grep "##answer" $absdir/$i | $sed 's/\/\* ##answer:\s\+\([^\*]\+\)\b\s*\*\//\1/g'`
+  printf $fmt "${i%.*}"
+  echo -n " ... "
+  if [ "$answer" == "$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=$(echo "$end $start" | $awk '{printf "%.2f", $1 - $2}')
+echo -e "\n$passes/$tests passed in $runtime""s"
+make clean > /dev/null
+exit $((tests-passes))

tac/tests/twice.c

@@ -0,0 +1,16 @@
+/* ##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() {
+  doublewhammy = twice(whammy);
+
+  return doublewhammy(2);
+}
+

tac/tests/var_maths.c

@@ -0,0 +1,9 @@
+/* ##answer: 30*/
+int main() {
+  int x = 5;
+  int y = x - 4;
+  int z = 10 - x;
+  int w = x % z;
+
+  return x*x + z / (w + y);
+}

tac/wew.asm

@@ -1,44 +0,0 @@
-li $a0, 68
-li $v0, 9
-syscall
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $0, 4($fp)
-jal main
-j done
-return_five:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, return_five
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-li $8, 5
-or $v1, $0, $8
-jr $31
-main:
-li $a0, 68
-li $v0, 9
-syscall
-sw $fp, 4($v0)
-or $fp, $0, $v0
-la $t0, main
-sw $t0, 0($fp)
-sw $ra, 64($fp)
-jal return_five
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-or $9, $0, $v1
-jal return_five
-lw $fp, 4($fp)
-lw $ra, 64($fp)
-or $10, $0, $v1
-add $11, $9, $10
-or $v1, $0, $11
-jr $31
-done:
-ori $v0, $0, 10
-syscall