fix repo

cw

@@ -1 +0,0 @@
-Subproject commit c853190fe5ac63dc0c95ff62146b750e1f116d8b

cw/.gitignore

@@ -0,0 +1,2 @@
+*.o
+mycc

cw/C.flex

@@ -0,0 +1,138 @@
+D			[0-9]
+L			[a-zA-Z_]
+H			[a-fA-F0-9]
+E			[Ee][+-]?{D}+
+FS			(f|F|l|L)
+IS			(u|U|l|L)*
+
+%{
+#include <stdio.h>
+#include "C.tab.h"
+#include <string.h>
+#include <stdlib.h>
+#include "token.h"
+TOKEN* make_string(char*);
+extern TOKEN* lookup_token(char*);
+TOKEN* make_int(char*);
+TOKEN* lasttok;
+
+void count(void);
+void comment(void);
+%}
+
+%%
+"/*"			{ comment(); }
+
+"auto"			{ count(); return(AUTO); }
+"break"			{ count(); return(BREAK); }
+"continue"		{ count(); return(CONTINUE); }
+"else"			{ count(); return(ELSE); }
+"extern"		{ count(); return(EXTERN); }
+"if"			{ count(); return(IF); }
+"int"			{ count(); return(INT); }
+"function"		{ count(); return(FUNCTION); }
+"return"		{ count(); return(RETURN); }
+"void"			{ count(); return(VOID); }
+"while"			{ count(); return(WHILE); }
+
+{L}({L}|{D})*		{ count(); lasttok = lookup_token(yytext);
+                          return(IDENTIFIER); }
+
+{D}+{IS}?		{ count(); lasttok = make_int(yytext);return(CONSTANT); }
+L?'(\\.|[^\\'])+'	{ count(); lasttok = make_int(yytext);return(CONSTANT); }
+
+L?\"(\\.|[^\\"])*\"	{ count(); lasttok = make_string(yytext);
+                          return(STRING_LITERAL); }
+
+"<="			{ count(); return(LE_OP); }
+">="			{ count(); return(GE_OP); }
+"=="			{ count(); return(EQ_OP); }
+"!="			{ count(); return(NE_OP); }
+";"			{ count(); return(';'); }
+"{"     		{ count(); return('{'); }
+"}"     		{ count(); return('}'); }
+","			{ count(); return(','); }
+":"			{ count(); return(':'); }
+"="			{ count(); return('='); }
+"("			{ count(); return('('); }
+")"			{ count(); return(')'); }
+"!"			{ count(); return('!'); }
+"-"			{ count(); return('-'); }
+"+"			{ count(); return('+'); }
+"*"			{ count(); return('*'); }
+"/"			{ count(); return('/'); }
+"%"			{ count(); return('%'); }
+"<"			{ count(); return('<'); }
+">"			{ count(); return('>'); }
+
+[ \t\v\n\f]		{ count(); }
+.			{ /* ignore bad characters */ }
+
+%%
+
+int yywrap(void)
+{
+	return(1);
+}
+
+
+void comment(void)
+{
+	char c, c1;
+
+loop:
+	while ((c = input()) != '*' && c != 0)
+		putchar(c);
+
+	if ((c1 = input()) != '/' && c != 0)
+	{
+		unput(c1);
+		goto loop;
+	}
+
+	if (c != 0)
+		putchar(c1);
+}
+
+
+int column = 0;
+
+void count()
+{
+	int i;
+
+	for (i = 0; yytext[i] != '\0'; i++)
+		if (yytext[i] == '\n')
+			column = 0;
+		else if (yytext[i] == '\t')
+			column += 8 - (column % 8);
+		else
+			column++;
+
+	ECHO;
+}
+
+
+TOKEN *new_token(int type)
+{
+    TOKEN *ans = (TOKEN*)malloc(sizeof(TOKEN));
+    ans->type = type;
+    return ans;
+}
+
+TOKEN *make_string(char *s)
+{
+    TOKEN *ans = new_token(STRING_LITERAL);
+    int len = strlen(s);
+    ans->lexeme = (char*)calloc(1, len-1);
+    strncpy(ans->lexeme, s+1, len-2);
+    return ans;
+}
+
+TOKEN *make_int(char *s)
+{
+    int n = *s!='\'' ? atoi(s) : *(s+1);
+    TOKEN *ans = new_token(CONSTANT);
+    ans->value = n;
+    return ans;
+}

cw/C.tab.h

@@ -0,0 +1,88 @@
+/* A Bison parser, made by GNU Bison 1.875.  */
+
+/* Skeleton parser for Yacc-like parsing with Bison,
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     IDENTIFIER = 258,
+     CONSTANT = 259,
+     STRING_LITERAL = 260,
+     LE_OP = 261,
+     GE_OP = 262,
+     EQ_OP = 263,
+     NE_OP = 264,
+     EXTERN = 265,
+     AUTO = 266,
+     INT = 267,
+     VOID = 268,
+     FUNCTION = 269,
+     APPLY = 270,
+     LEAF = 271,
+     IF = 272,
+     ELSE = 273,
+     WHILE = 274,
+     CONTINUE = 275,
+     BREAK = 276,
+     RETURN = 277
+   };
+#endif
+#define IDENTIFIER 258
+#define CONSTANT 259
+#define STRING_LITERAL 260
+#define LE_OP 261
+#define GE_OP 262
+#define EQ_OP 263
+#define NE_OP 264
+#define EXTERN 265
+#define AUTO 266
+#define INT 267
+#define VOID 268
+#define FUNCTION 269
+#define APPLY 270
+#define LEAF 271
+#define IF 272
+#define ELSE 273
+#define WHILE 274
+#define CONTINUE 275
+#define BREAK 276
+#define RETURN 277
+
+
+
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+typedef int YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+extern YYSTYPE yylval;
+
+
+

cw/C.y

@@ -0,0 +1,270 @@
+%{
+#include "nodes.h"
+#define YYSTYPE NODE*
+#define YYDEBUG 1
+extern TOKEN *int_token, *void_token, *function_token, *lasttok;
+NODE *ans;
+%}
+
+%token IDENTIFIER CONSTANT STRING_LITERAL
+%token LE_OP GE_OP EQ_OP NE_OP
+
+%token EXTERN AUTO
+%token INT VOID FUNCTION
+%token APPLY LEAF
+
+%token  IF ELSE WHILE CONTINUE BREAK RETURN
+
+%start goal
+%%
+
+goal    :  translation_unit { ans = $$ = $1;}
+        ;
+
+primary_expression
+	: IDENTIFIER 			{ $$ = make_leaf(lasttok); }
+	| CONSTANT 			{ $$ = make_leaf(lasttok); }
+	| STRING_LITERAL 		{ $$ = make_leaf(lasttok); }
+	| '(' expression ')' 		{ $$ = $2; }
+	;
+
+postfix_expression
+	: primary_expression		{ $$ = $1; }
+	| postfix_expression '(' ')'    { $$ = make_node(APPLY, $1, NULL); }
+	| postfix_expression '(' argument_expression_list ')' {
+				          $$ = make_node(APPLY, $1, $3); }
+	;
+
+argument_expression_list
+	: assignment_expression		{ $$ = $1; }
+	| argument_expression_list ',' assignment_expression {
+          $$ = make_node(',', $1, $3); }
+	;
+
+unary_expression
+	: postfix_expression		{ $$ = $1; }
+	| unary_operator unary_expression { $$ = make_node((int)$1, $2, NULL); }
+	;
+
+unary_operator
+	: '&'		{ $$ = $1; }
+	| '*'		{ $$ = $1; }
+	| '+'		{ $$ = $1; }
+	| '-'		{ $$ = $1; }
+	| '!'		{ $$ = $1; }
+	;
+
+multiplicative_expression
+	: unary_expression		{ $$ = $1; }
+	| multiplicative_expression '*' unary_expression {
+                                          $$ = make_node('*', $1, $3); }
+	| multiplicative_expression '/' unary_expression {
+                                          $$ = make_node('/', $1, $3); }
+	| multiplicative_expression '%' unary_expression {
+                                          $$ = make_node('%', $1, $3); }
+	;
+
+additive_expression
+	: multiplicative_expression		{ $$ = $1; }
+	| additive_expression '+' multiplicative_expression {
+                                          $$ = make_node('+', $1, $3); }
+	| additive_expression '-' multiplicative_expression {
+                                          $$ = make_node('-', $1, $3); }
+	;
+
+relational_expression
+	: additive_expression		{ $$ = $1; }
+	| relational_expression '<' additive_expression	{
+                                          $$ = make_node('<', $1, $3); }
+	| relational_expression '>' additive_expression {
+                                          $$ = make_node('>', $1, $3); }
+	| relational_expression LE_OP additive_expression {
+                                          $$ = make_node(LE_OP, $1, $3); }
+	| relational_expression GE_OP additive_expression {
+                                          $$ = make_node(GE_OP, $1, $3); }
+	;
+
+equality_expression
+	: relational_expression		{ $$ = $1; }
+	| equality_expression EQ_OP relational_expression {
+                                          $$ = make_node(EQ_OP, $1, $3); }
+	| equality_expression NE_OP relational_expression {
+                                          $$ = make_node(NE_OP, $1, $3); }
+	;
+
+assignment_expression
+	: equality_expression		{ $$ = $1; }
+	| unary_expression '=' assignment_expression {
+                                          $$ = make_node('=', $1, $3); }
+	;
+
+expression
+	: assignment_expression		{ $$ = $1; }
+	| expression ',' assignment_expression { $$ = make_node(',', $1, $3); }
+	;
+
+declaration
+	: declaration_specifiers ';'		{ $$ = $1; }
+	| function_definition			{ $$ = $1; }
+	| declaration_specifiers init_declarator_list ';' {
+                                                  $$ = make_node('~', $1, $2); }
+	;
+
+declaration_specifiers
+	: storage_class_specifier		{ $$ = $1; }
+	| storage_class_specifier declaration_specifiers { 
+                                                  $$ = make_node('~', $1, $2); }
+	| type_specifier	        	{ $$ = $1; }
+	| type_specifier declaration_specifiers { $$ = make_node('~', $1, $2); }
+	;
+
+init_declarator_list
+	: init_declarator		{ $$ = $1; }
+	| init_declarator_list ',' init_declarator { $$ = make_node(',', $1, $3); }
+	;
+
+init_declarator
+	: declarator		{ $$ = $1; }
+	| declarator '=' assignment_expression { $$ = make_node('=', $1, $3); }
+	;
+
+storage_class_specifier
+	: EXTERN	{ $$ = $1; }
+	| AUTO		{ $$ = $1; }
+	;
+
+type_specifier
+	: VOID		{ $$ = make_leaf(void_token); }
+	| INT		{ $$ = make_leaf(int_token); }
+	| FUNCTION	{ $$ = make_leaf(function_token); }
+	;
+
+declarator
+	: pointer direct_declarator	{ $$ = make_node('~', $1, $2); }
+	| direct_declarator		{ $$ = $1; }
+	;
+
+direct_declarator
+	: IDENTIFIER		{ $$ = make_leaf(lasttok); }
+	| '(' declarator ')'	{ $$ = $2; }
+        | direct_declarator '(' parameter_list ')' { $$ = make_node('F', $1, $3); }
+	| direct_declarator '(' identifier_list ')'{ $$ = make_node('F', $1, $3); }
+	| direct_declarator '(' ')'                { $$ = make_node('F', $1, NULL); }
+	;
+
+pointer
+	: '*'                   { $$ = (NODE*)1; }
+	| '*' pointer           { $$ = (NODE*)((int)$2+1); }
+	;
+
+parameter_list
+	: parameter_declaration		{ $$ = $1; }
+	| parameter_list ',' parameter_declaration { $$ = make_node(',', $1, $3); }
+	;
+
+parameter_declaration
+	: declaration_specifiers declarator { $$ = make_node('~', $1, $2); }
+	| declaration_specifiers abstract_declarator { $$ = make_node('~', $1, $2); }
+	| declaration_specifiers	{ $$ = $1; }
+	;
+
+identifier_list
+	: IDENTIFIER                    { $$ = make_leaf(lasttok); }
+	| identifier_list ',' IDENTIFIER {
+                                          $$ = make_node(',', $1,
+                                                              make_leaf(lasttok)); }
+	;
+
+abstract_declarator
+	: pointer		        { $$ = $1; }
+	| direct_abstract_declarator    { $$ = $1; }
+	| pointer direct_abstract_declarator { $$ = make_node('G', $1, $2); }
+	;
+
+direct_abstract_declarator
+	: '(' abstract_declarator ')'    { $$ = $2; }
+	| '(' ')'    { $$ = NULL; }
+	| '(' parameter_list ')'    { $$ = $2; }
+	| direct_abstract_declarator '(' ')'    { $$ = make_node(APPLY, $1, NULL); }
+	| direct_abstract_declarator '(' parameter_list ')'   { $$ = make_node(APPLY, $1, $3); }
+	;
+
+statement
+	: compound_statement		{ $$ = $1; }
+	| expression_statement		{ $$ = $1; }
+	| selection_statement		{ $$ = $1; }
+	| iteration_statement		{ $$ = $1; }
+	| jump_statement		{ $$ = $1; }
+	;
+
+compound_statement
+	: '{' '}'                       { $$ = NULL; }
+	| '{' statement_list '}'	{ $$ = $2; }
+	| '{' declaration_list '}'	{ $$ = $2; }
+	| '{' declaration_list statement_list '}' { $$ = make_node(';', $2, $3); }
+	;
+
+declaration_list
+	: declaration			{ $$ = $1; }
+	| declaration_list declaration { $$ = make_node(';', $1, $2); }
+	;
+
+statement_list
+	: statement			{ $$ = $1; }
+	| statement_list statement 	{ $$ = make_node(';', $1, $2); }
+	;
+
+expression_statement
+	: ';'				{ $$ = NULL; }
+	| expression ';'		{ $$ = $1; }
+	;
+
+selection_statement
+	: IF '(' expression ')' statement { $$ = make_node(IF, $3, $5); }
+	| IF '(' expression ')' statement ELSE statement
+                                          { $$ = make_node(IF, $3,
+                                                        make_node(ELSE, $5, $7)); }
+	;
+
+iteration_statement
+	: WHILE '(' expression ')' statement { $$ = make_node(WHILE, $3, $5); }
+	;
+
+jump_statement
+	: CONTINUE ';'                  { $$ = make_node(CONTINUE, NULL, NULL); }
+	| BREAK ';'                     { $$ = make_node(BREAK, NULL, NULL); }
+	| RETURN ';'	                { $$ = make_node(RETURN, NULL, NULL); }
+	| RETURN expression ';'		{ $$ = make_node(RETURN, $2, NULL); }
+	;
+
+translation_unit
+	: external_declaration		{ $$ = $1; }
+	| translation_unit external_declaration { $$ = make_node('~', $1, $2);}
+	;
+
+external_declaration
+	: function_definition            { $$ = $1; }
+	| declaration                    { $$ = $1; }
+	;
+
+function_definition
+	: declaration_specifiers declarator declaration_list compound_statement {
+          $$ = make_node('D', make_node('d', $1, make_node('e', $2, $3)), $4); }
+	| declaration_specifiers declarator compound_statement  {
+          $$ = make_node('D', make_node('d', $1, $2), $3); }
+	| declarator declaration_list compound_statement  {
+          $$ = make_node('D', make_node('d', $1, $2), $3); }
+	| declarator compound_statement { $$ = make_node('D', $1, $2); }
+        ;
+%%
+#include <stdio.h>
+
+extern char yytext[];
+extern int column;
+
+int yyerror(char *s)
+{
+	fflush(stdout);
+	printf("\n%*s\n%*s\n", column, "^", column, s);
+}
+

cw/Makefile

@@ -0,0 +1,28 @@
+OBJS = lex.yy.o C.tab.o symbol_table.o nodes.o main.o list.o
+SRCS = lex.yy.c C.tab.c symbol_table.c nodes.c main.c list.c
+CC = gcc -Wall -Wextra -Wpedantic -g
+
+all:	mycc
+
+clean:
+	rm ${OBJS}
+
+mycc:	${OBJS}
+	${CC} -g -o mycc ${OBJS} 
+
+lex.yy.c: C.flex
+	flex C.flex
+
+C.tab.c:	C.y
+	bison -d -t -v C.y
+
+.c.o:
+	${CC} -g -c $*.c
+
+depend:	
+	${CC} -M $(SRCS) > .deps
+	cat Makefile .deps > makefile
+
+dist:	symbol_table.c nodes.c main.c Makefile C.flex C.y nodes.h token.h
+	tar cvfz mycc.tgz symbol_table.c nodes.c main.c Makefile C.flex C.y \
+		nodes.h token.h

cw/README.md

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

cw/list.c

@@ -0,0 +1,67 @@
+#include "list.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+BLIST* create_list(BIND *binding, BLIST *second) {
+  BLIST *head = (BLIST*) malloc(sizeof(BLIST));
+  if (head == NULL) {
+    perror("Failed to create list: ");
+    exit(1);
+  }
+  head->binding = binding;
+  head->next = second;
+  return head;
+}
+
+ENV* create_new_function_env(ENV* env) {
+  ENV* n_env = (ENV*) malloc(sizeof(ENV));
+  if (n_env == NULL) {
+    perror("Failed to create environment");
+    exit(1);
+  }
+  n_env->bindings = NULL;
+  n_env->parent = env;
+  return n_env;
+}
+
+BIND* create_binding(TOKEN* name, NODE* tree, ENV* env_ptr) {
+  BIND* n_bind = (BIND*) malloc(sizeof(BIND));
+  if (n_bind == NULL) {
+    perror("Failed to create binding: ");
+    exit(1);
+  }
+  n_bind->name = name;
+  n_bind->tree = tree;
+  n_bind->env  = env_ptr;
+
+  return n_bind;
+}
+
+void append_list(BLIST *head, BIND *binding) {
+  BLIST *ptr = head;
+  while (ptr->next != NULL) {
+    ptr = ptr->next;
+  }
+  ptr->next = create_list(binding, NULL);
+}
+
+BIND* find_name_in_list(TOKEN* name, BLIST *head) {
+  BLIST *ptr = head;
+  while (ptr != NULL) {
+    if (ptr->binding->name == name) {
+      return ptr->binding;
+    }
+    ptr = ptr->next;
+  }
+  return NULL;
+}
+
+  BIND* find_name_in_env(TOKEN* name, ENV* env) {
+    BIND* ptr = NULL;
+    ENV* env_ptr = env;
+    while (env_ptr != NULL && 
+        (ptr = find_name_in_list(name, env_ptr->bindings)) == NULL) env_ptr = env_ptr->parent;
+  return ptr;
+}
+

cw/list.h

@@ -0,0 +1,12 @@
+#ifndef LIST_H
+#define LIST_H
+#include "types.h"
+
+BLIST* create_list(BIND*, BLIST*);
+BIND* create_binding(TOKEN*, NODE*, ENV*);
+void append_list(BLIST*, BIND*);
+BIND* find_name_in_list(TOKEN*, BLIST*);
+BIND* find_name_in_env(TOKEN*, ENV*);
+ENV* create_new_function_env(ENV*);
+#endif
+

cw/main.c

@@ -0,0 +1,295 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "nodes.h"
+#include "C.tab.h"
+#include "types.h"
+#include "list.h"
+
+TOKEN* lookup_token(char *s);
+
+/*
+ * Existing problems/todo:
+ * return from control block, need a "return address" to jump to -- call levels
+ * --multiple assignments `int x,y,z = 1`--
+ * new block scope for if statements?
+ * arguments for functions
+ * difference between tilde and semicolon
+ * while loops
+ * control flow `continue` and `break` linked to return address sort of? call levels
+ */
+
+char *named(int t) {
+    static char b[100];
+    if (isgraph(t) || t==' ') {
+      sprintf(b, "%c", t);
+      return b;
+    }
+    switch (t) {
+      default: return "???";
+    case IDENTIFIER:
+      return "id";
+    case CONSTANT:
+      return "constant";
+    case STRING_LITERAL:
+      return "string";
+    case LE_OP:
+      return "<=";
+    case GE_OP:
+      return ">=";
+    case EQ_OP:
+      return "==";
+    case NE_OP:
+      return "!=";
+    case EXTERN:
+      return "extern";
+    case AUTO:
+      return "auto";
+    case INT:
+      return "int";
+    case VOID:
+      return "void";
+    case APPLY:
+      return "apply";
+    case LEAF:
+      return "leaf";
+    case IF:
+      return "if";
+    case ELSE:
+      return "else";
+    case WHILE:
+      return "while";
+    case CONTINUE:
+      return "continue";
+    case BREAK:
+      return "break";
+    case RETURN:
+      return "return";
+    }
+}
+
+
+
+void print_leaf(NODE *tree, int level) {
+    TOKEN *t = (TOKEN *)tree;
+    int i;
+    for (i=0; i<level; i++) putchar(' ');
+    if (t->type == CONSTANT) printf("%d\n", t->value);
+    else if (t->type == STRING_LITERAL) printf("\"%s\"\n", t->lexeme);
+    else if (t) puts(t->lexeme);
+}
+
+void print_tree0(NODE *tree, int level) {
+    int i;
+    if (tree==NULL) return;
+    if (tree->type==LEAF) {
+      print_leaf(tree->left, level);
+    }
+    else {
+      for(i=0; i<level; i++) putchar(' ');
+      printf("%s\n", named(tree->type));
+
+/*       if (tree->type=='~') { */
+/*         for(i=0; i<level+2; i++) putchar(' '); */
+/*         printf("%p\n", tree->left); */
+/*       } */
+/*       else */
+        print_tree0(tree->left, level+2);
+      print_tree0(tree->right, level+2);
+    }
+}
+
+// forward declare because it is used in add_var_to_env
+int recursive_interpret(NODE*, ENV*);
+
+void print_tree(NODE *tree) {
+    print_tree0(tree, 0);
+}
+
+void add_function_to_env(NODE *tree, ENV *env_ptr) {
+  BIND* existing;
+  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) {
+    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;
+  }
+}
+
+
+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(INT);
+  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);
+    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);
+    existing->tree = (NODE *) tok;
+  } 
+}
+
+int recursive_interpret(NODE *tree, ENV *env_ptr) {
+  if (tree==NULL) return 0;
+  if (tree->type==LEAF) {
+    if (tree->left->type == CONSTANT) {
+      return ((TOKEN *) tree->left)->value;
+    } 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
+      return 0;
+    } else {
+      // an identifier
+      TOKEN* tok = (TOKEN *) tree->left;
+      BIND* var_bind = find_name_in_env(tok, env_ptr);
+      if (var_bind == NULL) {
+        printf("Could not find variable %s\n", tok->lexeme);
+        exit(1);
+      }
+      if (var_bind->tree->type == INT) {
+        TOKEN* var_tok = (TOKEN *) var_bind->tree;
+        return var_tok->value;
+      } else {
+        printf("Maybe got a function?\n");
+        return 0;
+      }
+    }
+  }
+  if (tree->type=='D') {
+    // this is a function definition
+    add_function_to_env(tree, env_ptr);
+    return 0;
+  }
+  if (tree->type=='=') {
+    // this is a variable definition
+    add_var_to_env(tree, env_ptr);
+    return 0;
+  }
+  if (tree->type==APPLY) {
+    TOKEN* func_name = ((TOKEN*) tree->left->left);
+    BIND* func = find_name_in_env(func_name, env_ptr);
+    if (func == NULL) {
+      printf("Could not find binding for function with name %s\n", func_name->lexeme);
+      exit(1);
+    }
+    return recursive_interpret(func->tree->right, func->env);
+  }
+  if (tree->type == IF) {
+    if (recursive_interpret(tree->left, env_ptr) == 1) {
+      if (tree->right->type == ELSE) {
+        return recursive_interpret(tree->right->left, env_ptr);
+      } else {
+        return recursive_interpret(tree->right, env_ptr);
+      }
+    } else {
+      if (tree->right->type == ELSE) {
+        return recursive_interpret(tree->right->right, env_ptr);
+      }
+      return 0;
+    }
+  }
+  if (tree->type == LE_OP) {
+    return (int)recursive_interpret(tree->left, env_ptr) <= recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == GE_OP) {
+    return (int)recursive_interpret(tree->left, env_ptr) >= recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == EQ_OP) {
+    return (int)recursive_interpret(tree->left, env_ptr) == recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == NE_OP) {
+    return (int)recursive_interpret(tree->left, env_ptr) != recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '>') {
+    return (int)recursive_interpret(tree->left, env_ptr) > recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '<') {
+    return (int)recursive_interpret(tree->left, env_ptr) < recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '+') {
+    return recursive_interpret(tree->left, env_ptr) + recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '-') {
+    return recursive_interpret(tree->left, env_ptr) - recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '*') {
+    return recursive_interpret(tree->left, env_ptr) * recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '/') {
+    return recursive_interpret(tree->left, env_ptr) / recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '%') {
+    return recursive_interpret(tree->left, env_ptr) % recursive_interpret(tree->right, env_ptr);
+  }
+  if (tree->type == '~') {
+    if (tree->left->type == INT || tree->left->type == FUNCTION) {
+      return recursive_interpret(tree->right, env_ptr);
+    } else {
+      recursive_interpret(tree->left, env_ptr);
+      return recursive_interpret(tree->right, env_ptr);
+    }
+  }
+  if (tree->type == RETURN) {
+    return recursive_interpret(tree->left, env_ptr);
+  }
+  recursive_interpret(tree->left, env_ptr);
+  return recursive_interpret(tree->right, env_ptr);
+}
+
+ENV* cons_global_env(NODE *tree) {
+  ENV* global = create_new_function_env(NULL);
+  recursive_interpret(tree, global);
+  return global;
+}
+
+void interpret_tree(NODE *tree) {
+  ENV* global_env = cons_global_env(tree);
+  BIND* ref_main = find_name_in_env(lookup_token("main"), global_env);
+  if (ref_main == NULL) {
+    printf("Could not find main, cannot run!\n");
+    exit(1);
+  }
+  // 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));
+}
+
+extern int yydebug;
+extern NODE* yyparse(void);
+extern NODE* ans;
+extern void init_symbtable(void);
+
+int main(int argc, char** argv)
+{
+    NODE* tree;
+    if (argc>1 && strcmp(argv[1],"-d")==0) yydebug = 1;
+    init_symbtable();
+    printf("--C COMPILER\n");
+    yyparse();
+    tree = ans;
+    printf("parse finished\n");
+    print_tree(tree);
+    interpret_tree(tree);
+    return 0;
+}

cw/nodes.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "nodes.h"
+#include "C.tab.h"
+
+NODE* make_node(int t, NODE* left, NODE* right)
+{
+    NODE *a = (NODE*)malloc(sizeof(NODE));
+    if (a==NULL) {
+      perror("Cannot make node");
+      exit(1);
+    }
+    a->type = t;
+    a->left = left;
+    a->right = right;
+    return a;
+}
+
+NODE* make_leaf(TOKEN* l)
+{
+    NODE *a = (NODE*)malloc(sizeof(NODE));
+/*     printf("make_leaf: %p -> %p\n", l, a); */
+    if (a==NULL) {
+      perror("Cannot make leaf");
+      exit(1);
+    }
+    a->type = LEAF;
+    a->left = (NODE*)l;
+    a->right = NULL;
+    return a;
+}

cw/nodes.h

@@ -0,0 +1,13 @@
+#ifndef NODES_H
+#define NODES_H
+#include "token.h"
+
+typedef struct node {
+  int          type;
+  struct node *left;
+  struct node *right;
+} NODE;
+
+NODE* make_leaf(TOKEN*);
+NODE* make_node(int, NODE*, NODE*);
+#endif

cw/prog.c

@@ -0,0 +1,11 @@
+int main() {
+  int a = 1;
+  int d = 1;
+
+  return 1;
+}
+
+int other_f() {
+  int b = 2;
+  return 2;
+}

cw/simple.c

@@ -0,0 +1,9 @@
+int main() {
+
+  int foo = 1 + 4;
+  int bar = 2 + foo;
+
+  int baz = foo + bar;
+
+  return baz;
+}

cw/symbol_table.c

@@ -0,0 +1,58 @@
+/*
+ * Adapted from 
+ * CM20029 Coursework Assignment 1
+ * Tom Crick
+ * cs1tc@bath.ac.uk
+ * 30 Apr 2003
+ *
+ * symbol_table.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "token.h"
+#include "C.tab.h"
+
+static TOKEN** symbtable;
+#define HASH_SIZE (1000)
+TOKEN *int_token, *void_token, *function_token;
+
+void init_symbtable(void)
+{
+    symbtable = (TOKEN**)calloc(HASH_SIZE, sizeof(TOKEN*));
+    int_token = new_token(INT);
+    int_token->lexeme = "int";
+    function_token = new_token(FUNCTION);
+    function_token->lexeme = "function";
+    void_token = new_token(VOID);
+    void_token->lexeme = "void";
+}
+
+int hash(char *s)
+{
+    int h = 0;
+    while (*s != '\0') {
+      h = (h<<4) ^ *s++;
+    }
+    return (0x7fffffff&h) % HASH_SIZE;
+}
+
+TOKEN* lookup_token(char *s)
+{
+    int	h = hash(s);
+    TOKEN *a = symbtable[h];
+    TOKEN *ans;
+/*     printf("\nLookup: %s\n", s); */
+    while (a!=NULL) {
+      if (strcmp(a->lexeme, s)==0) return a;
+      a = a->next;
+    }
+    ans = new_token(IDENTIFIER);
+    ans->lexeme = (char*)malloc(1+strlen(s));
+    strcpy(ans->lexeme, s);
+    ans->next = symbtable[h];
+    symbtable[h] = ans;
+/*     printf(" stored at %p\n", ans); */
+    return ans;
+}

cw/token.h

@@ -0,0 +1,18 @@
+#ifndef __TOKEN_H
+#define __TOKEN_H
+
+#define TRUE 1
+#define FALSE 0
+#define TEST_MODE 0
+
+typedef struct TOKEN
+{
+  int           type;
+  char          *lexeme;
+  int           value;
+  struct TOKEN  *next;
+} TOKEN;
+
+extern TOKEN* new_token(int);
+
+#endif

cw/types.h

@@ -0,0 +1,21 @@
+#ifndef TYPES_H
+#define TYPES_H
+#include "nodes.h"
+
+typedef struct binding {
+  TOKEN* name;
+  NODE* tree;
+  struct environ *env;
+} BIND;
+
+typedef struct blist {
+  BIND* binding;
+  struct blist *next;
+} BLIST;
+
+typedef struct environ {
+  BLIST *bindings;
+  struct environ *parent;
+} ENV;
+
+#endif

tac

@@ -1 +0,0 @@
-Subproject commit c853190fe5ac63dc0c95ff62146b750e1f116d8b

tac/.gitignore

@@ -0,0 +1,2 @@
+*.o
+mycc

tac/C.flex

@@ -0,0 +1,144 @@
+D			[0-9]
+L			[a-zA-Z_]
+H			[a-fA-F0-9]
+E			[Ee][+-]?{D}+
+FS			(f|F|l|L)
+IS			(u|U|l|L)*
+
+%{
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wextra"
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wpedantic"
+#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
+#include <stdio.h>
+#include "C.tab.h"
+#include <string.h>
+#include <stdlib.h>
+#include "token.h"
+TOKEN* make_string(char*);
+extern TOKEN* lookup_token(char*);
+TOKEN* make_int(char*);
+TOKEN* lasttok;
+
+void count(void);
+void comment(void);
+%}
+
+%%
+"/*"			{ comment(); }
+
+"auto"			{ count(); return(AUTO); }
+"break"			{ count(); return(BREAK); }
+"continue"		{ count(); return(CONTINUE); }
+"else"			{ count(); return(ELSE); }
+"extern"		{ count(); return(EXTERN); }
+"if"			{ count(); return(IF); }
+"int"			{ count(); return(INT); }
+"function"		{ count(); return(FUNCTION); }
+"return"		{ count(); return(RETURN); }
+"void"			{ count(); return(VOID); }
+"while"			{ count(); return(WHILE); }
+
+{L}({L}|{D})*		{ count(); lasttok = lookup_token(yytext);
+                          return(IDENTIFIER); }
+
+{D}+{IS}?		{ count(); lasttok = make_int(yytext);return(CONSTANT); }
+L?'(\\.|[^\\'])+'	{ count(); lasttok = make_int(yytext);return(CONSTANT); }
+
+L?\"(\\.|[^\\"])*\"	{ count(); lasttok = make_string(yytext);
+                          return(STRING_LITERAL); }
+
+"<="			{ count(); return(LE_OP); }
+">="			{ count(); return(GE_OP); }
+"=="			{ count(); return(EQ_OP); }
+"!="			{ count(); return(NE_OP); }
+";"			{ count(); return(';'); }
+"{"     		{ count(); return('{'); }
+"}"     		{ count(); return('}'); }
+","			{ count(); return(','); }
+":"			{ count(); return(':'); }
+"="			{ count(); return('='); }
+"("			{ count(); return('('); }
+")"			{ count(); return(')'); }
+"!"			{ count(); return('!'); }
+"-"			{ count(); return('-'); }
+"+"			{ count(); return('+'); }
+"*"			{ count(); return('*'); }
+"/"			{ count(); return('/'); }
+"%"			{ count(); return('%'); }
+"<"			{ count(); return('<'); }
+">"			{ count(); return('>'); }
+
+[ \t\v\n\f]		{ count(); }
+.			{ /* ignore bad characters */ }
+
+%%
+
+int yywrap(void)
+{
+	return(1);
+}
+
+
+void comment(void)
+{
+	char c, c1;
+
+loop:
+	while ((c = input()) != '*' && c != 0)
+		putchar(c);
+
+	if ((c1 = input()) != '/' && c != 0)
+	{
+		unput(c1);
+		goto loop;
+	}
+
+	if (c != 0)
+		putchar(c1);
+}
+
+
+int column = 0;
+
+void count()
+{
+	int i;
+
+	for (i = 0; yytext[i] != '\0'; i++)
+		if (yytext[i] == '\n')
+			column = 0;
+		else if (yytext[i] == '\t')
+			column += 8 - (column % 8);
+		else
+			column++;
+
+	ECHO;
+}
+
+
+TOKEN *new_token(int type)
+{
+    TOKEN *ans = (TOKEN*)malloc(sizeof(TOKEN));
+    ans->type = type;
+    return ans;
+}
+
+TOKEN *make_string(char *s)
+{
+    TOKEN *ans = new_token(STRING_LITERAL);
+    int len = strlen(s);
+    ans->lexeme = (char*)calloc(1, len-1);
+    strncpy(ans->lexeme, s+1, len-2);
+    return ans;
+}
+
+TOKEN *make_int(char *s)
+{
+    int n = *s!='\'' ? atoi(s) : *(s+1);
+    TOKEN *ans = new_token(CONSTANT);
+    ans->value = n;
+    asprintf(&ans->lexeme, "%d", n);
+    return ans;
+}

tac/C.tab.h

@@ -0,0 +1,83 @@
+/* A Bison parser, made by GNU Bison 3.0.4.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+#ifndef YY_YY_C_TAB_H_INCLUDED
+# define YY_YY_C_TAB_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 1
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    IDENTIFIER = 258,
+    CONSTANT = 259,
+    STRING_LITERAL = 260,
+    LE_OP = 261,
+    GE_OP = 262,
+    EQ_OP = 263,
+    NE_OP = 264,
+    EXTERN = 265,
+    AUTO = 266,
+    INT = 267,
+    VOID = 268,
+    FUNCTION = 269,
+    APPLY = 270,
+    LEAF = 271,
+    IF = 272,
+    ELSE = 273,
+    WHILE = 274,
+    CONTINUE = 275,
+    BREAK = 276,
+    RETURN = 277
+  };
+#endif
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef int YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+
+#endif /* !YY_YY_C_TAB_H_INCLUDED  */

tac/C.y

@@ -0,0 +1,275 @@
+%{
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wpedantic"
+#pragma GCC diagnostic ignored "-Wextra"
+#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
+#include "nodes.h"
+#define YYSTYPE NODE*
+#define YYDEBUG 1
+extern TOKEN *int_token, *void_token, *function_token, *lasttok;
+NODE *ans;
+%}
+
+%token IDENTIFIER CONSTANT STRING_LITERAL
+%token LE_OP GE_OP EQ_OP NE_OP
+
+%token EXTERN AUTO
+%token INT VOID FUNCTION
+%token APPLY LEAF
+
+%token  IF ELSE WHILE CONTINUE BREAK RETURN
+
+%start goal
+%%
+
+goal    :  translation_unit { ans = $$ = $1;}
+        ;
+
+primary_expression
+	: IDENTIFIER 			{ $$ = make_leaf(lasttok); }
+	| CONSTANT 			{ $$ = make_leaf(lasttok); }
+	| STRING_LITERAL 		{ $$ = make_leaf(lasttok); }
+	| '(' expression ')' 		{ $$ = $2; }
+	;
+
+postfix_expression
+	: primary_expression		{ $$ = $1; }
+	| postfix_expression '(' ')'    { $$ = make_node(APPLY, $1, NULL); }
+	| postfix_expression '(' argument_expression_list ')' {
+				          $$ = make_node(APPLY, $1, $3); }
+	;
+
+argument_expression_list
+	: assignment_expression		{ $$ = $1; }
+	| argument_expression_list ',' assignment_expression {
+          $$ = make_node(',', $1, $3); }
+	;
+
+unary_expression
+	: postfix_expression		{ $$ = $1; }
+	| unary_operator unary_expression { $$ = make_node((int)$1, $2, NULL); }
+	;
+
+unary_operator
+	: '&'		{ $$ = $1; }
+	| '*'		{ $$ = $1; }
+	| '+'		{ $$ = $1; }
+	| '-'		{ $$ = $1; }
+	| '!'		{ $$ = $1; }
+	;
+
+multiplicative_expression
+	: unary_expression		{ $$ = $1; }
+	| multiplicative_expression '*' unary_expression {
+                                          $$ = make_node('*', $1, $3); }
+	| multiplicative_expression '/' unary_expression {
+                                          $$ = make_node('/', $1, $3); }
+	| multiplicative_expression '%' unary_expression {
+                                          $$ = make_node('%', $1, $3); }
+	;
+
+additive_expression
+	: multiplicative_expression		{ $$ = $1; }
+	| additive_expression '+' multiplicative_expression {
+                                          $$ = make_node('+', $1, $3); }
+	| additive_expression '-' multiplicative_expression {
+                                          $$ = make_node('-', $1, $3); }
+	;
+
+relational_expression
+	: additive_expression		{ $$ = $1; }
+	| relational_expression '<' additive_expression	{
+                                          $$ = make_node('<', $1, $3); }
+	| relational_expression '>' additive_expression {
+                                          $$ = make_node('>', $1, $3); }
+	| relational_expression LE_OP additive_expression {
+                                          $$ = make_node(LE_OP, $1, $3); }
+	| relational_expression GE_OP additive_expression {
+                                          $$ = make_node(GE_OP, $1, $3); }
+	;
+
+equality_expression
+	: relational_expression		{ $$ = $1; }
+	| equality_expression EQ_OP relational_expression {
+                                          $$ = make_node(EQ_OP, $1, $3); }
+	| equality_expression NE_OP relational_expression {
+                                          $$ = make_node(NE_OP, $1, $3); }
+	;
+
+assignment_expression
+	: equality_expression		{ $$ = $1; }
+	| unary_expression '=' assignment_expression {
+                                          $$ = make_node('=', $1, $3); }
+	;
+
+expression
+	: assignment_expression		{ $$ = $1; }
+	| expression ',' assignment_expression { $$ = make_node(',', $1, $3); }
+	;
+
+declaration
+	: declaration_specifiers ';'		{ $$ = $1; }
+	| function_definition			{ $$ = $1; }
+	| declaration_specifiers init_declarator_list ';' {
+                                                  $$ = make_node('~', $1, $2); }
+	;
+
+declaration_specifiers
+	: storage_class_specifier		{ $$ = $1; }
+	| storage_class_specifier declaration_specifiers { 
+                                                  $$ = make_node('~', $1, $2); }
+	| type_specifier	        	{ $$ = $1; }
+	| type_specifier declaration_specifiers { $$ = make_node('~', $1, $2); }
+	;
+
+init_declarator_list
+	: init_declarator		{ $$ = $1; }
+	| init_declarator_list ',' init_declarator { $$ = make_node(',', $1, $3); }
+	;
+
+init_declarator
+	: declarator		{ $$ = $1; }
+	| declarator '=' assignment_expression { $$ = make_node('=', $1, $3); }
+	;
+
+storage_class_specifier
+	: EXTERN	{ $$ = $1; }
+	| AUTO		{ $$ = $1; }
+	;
+
+type_specifier
+	: VOID		{ $$ = make_leaf(void_token); }
+	| INT		{ $$ = make_leaf(int_token); }
+	| FUNCTION	{ $$ = make_leaf(function_token); }
+	;
+
+declarator
+	: pointer direct_declarator	{ $$ = make_node('~', $1, $2); }
+	| direct_declarator		{ $$ = $1; }
+	;
+
+direct_declarator
+	: IDENTIFIER		{ $$ = make_leaf(lasttok); }
+	| '(' declarator ')'	{ $$ = $2; }
+        | direct_declarator '(' parameter_list ')' { $$ = make_node('F', $1, $3); }
+	| direct_declarator '(' identifier_list ')'{ $$ = make_node('F', $1, $3); }
+	| direct_declarator '(' ')'                { $$ = make_node('F', $1, NULL); }
+	;
+
+pointer
+	: '*'                   { $$ = (NODE*)1; }
+	| '*' pointer           { $$ = (NODE*)((int)$2+1); }
+	;
+
+parameter_list
+	: parameter_declaration		{ $$ = $1; }
+	| parameter_list ',' parameter_declaration { $$ = make_node(',', $1, $3); }
+	;
+
+parameter_declaration
+	: declaration_specifiers declarator { $$ = make_node('~', $1, $2); }
+	| declaration_specifiers abstract_declarator { $$ = make_node('~', $1, $2); }
+	| declaration_specifiers	{ $$ = $1; }
+	;
+
+identifier_list
+	: IDENTIFIER                    { $$ = make_leaf(lasttok); }
+	| identifier_list ',' IDENTIFIER {
+                                          $$ = make_node(',', $1,
+                                                              make_leaf(lasttok)); }
+	;
+
+abstract_declarator
+	: pointer		        { $$ = $1; }
+	| direct_abstract_declarator    { $$ = $1; }
+	| pointer direct_abstract_declarator { $$ = make_node('G', $1, $2); }
+	;
+
+direct_abstract_declarator
+	: '(' abstract_declarator ')'    { $$ = $2; }
+	| '(' ')'    { $$ = NULL; }
+	| '(' parameter_list ')'    { $$ = $2; }
+	| direct_abstract_declarator '(' ')'    { $$ = make_node(APPLY, $1, NULL); }
+	| direct_abstract_declarator '(' parameter_list ')'   { $$ = make_node(APPLY, $1, $3); }
+	;
+
+statement
+	: compound_statement		{ $$ = $1; }
+	| expression_statement		{ $$ = $1; }
+	| selection_statement		{ $$ = $1; }
+	| iteration_statement		{ $$ = $1; }
+	| jump_statement		{ $$ = $1; }
+	;
+
+compound_statement
+	: '{' '}'                       { $$ = NULL; }
+	| '{' statement_list '}'	{ $$ = $2; }
+	| '{' declaration_list '}'	{ $$ = $2; }
+	| '{' declaration_list statement_list '}' { $$ = make_node(';', $2, $3); }
+	;
+
+declaration_list
+	: declaration			{ $$ = $1; }
+	| declaration_list declaration { $$ = make_node(';', $1, $2); }
+	;
+
+statement_list
+	: statement			{ $$ = $1; }
+	| statement_list statement 	{ $$ = make_node(';', $1, $2); }
+	;
+
+expression_statement
+	: ';'				{ $$ = NULL; }
+	| expression ';'		{ $$ = $1; }
+	;
+
+selection_statement
+	: IF '(' expression ')' statement { $$ = make_node(IF, $3, $5); }
+	| IF '(' expression ')' statement ELSE statement
+                                          { $$ = make_node(IF, $3,
+                                                        make_node(ELSE, $5, $7)); }
+	;
+
+iteration_statement
+	: WHILE '(' expression ')' statement { $$ = make_node(WHILE, $3, $5); }
+	;
+
+jump_statement
+	: CONTINUE ';'                  { $$ = make_node(CONTINUE, NULL, NULL); }
+	| BREAK ';'                     { $$ = make_node(BREAK, NULL, NULL); }
+	| RETURN ';'	                { $$ = make_node(RETURN, NULL, NULL); }
+	| RETURN expression ';'		{ $$ = make_node(RETURN, $2, NULL); }
+	;
+
+translation_unit
+	: external_declaration		{ $$ = $1; }
+	| translation_unit external_declaration { $$ = make_node('~', $1, $2);}
+	;
+
+external_declaration
+	: function_definition            { $$ = $1; }
+	| declaration                    { $$ = $1; }
+	;
+
+function_definition
+	: declaration_specifiers declarator declaration_list compound_statement {
+          $$ = make_node('D', make_node('d', $1, make_node('e', $2, $3)), $4); }
+	| declaration_specifiers declarator compound_statement  {
+          $$ = make_node('D', make_node('d', $1, $2), $3); }
+	| declarator declaration_list compound_statement  {
+          $$ = make_node('D', make_node('d', $1, $2), $3); }
+	| declarator compound_statement { $$ = make_node('D', $1, $2); }
+        ;
+%%
+#include <stdio.h>
+
+extern char yytext[];
+extern int column;
+
+int yyerror(char *s)
+{
+	fflush(stdout);
+	printf("\n%*s\n%*s\n", column, "^", column, s);
+}
+

tac/Makefile

@@ -0,0 +1,30 @@
+CFLAGS := -g -std=gnu11
+OBJS := lex.yy.o C.tab.o symbol_table.o nodes.o main.o list.o
+SRCS := lex.yy.c C.tab.c symbol_table.c nodes.c main.c list.c
+CC := gcc
+
+all:	mycc
+
+clean:
+	rm -f ${OBJS}
+	rm -f C.tab.c lex.yy.c
+
+mycc:	${OBJS}
+	${CC} ${CFLAGS} -o mycc ${OBJS} 
+
+lex.yy.c: C.flex
+	flex C.flex
+
+C.tab.c:	C.y
+	bison -d -t C.y
+
+.c.o:
+	${CC} ${CFLAGS} -c $*.c
+
+depend:	
+	${CC} ${CFLAGS} -M $(SRCS) > .deps
+	cat Makefile .deps > makefile
+
+dist:	symbol_table.c nodes.c main.c Makefile C.flex C.y nodes.h token.h
+	tar cvfz mycc.tgz symbol_table.c nodes.c main.c Makefile C.flex C.y \
+		nodes.h token.h

tac/README.md

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

tac/list.c

@@ -0,0 +1,142 @@
+#include "list.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef void* any_t;
+
+typedef struct list_t {
+  any_t elem;
+  struct list_t *next;
+} LIST_T;
+
+LIST_T* new_list(any_t element) {
+
+  LIST_T *head = (LIST_T *) malloc(sizeof(LIST_T));
+  if (head == NULL) {
+    perror("failed to create list: ");
+    exit(1);
+  }
+  head->elem = element;
+  head->next = NULL;
+  return head;
+}
+
+void push_list(LIST_T **head, any_t element) {
+  LIST_T* n_head = (LIST_T *) malloc(sizeof(LIST_T));
+  if (n_head == NULL) perror("failed to allocate new element: ");
+  n_head->elem = element;
+  n_head->next = *head;
+  *head = n_head;
+}
+
+void append_to_list(LIST_T *head, any_t element) {
+  LIST_T* ptr = head;
+  LIST_T* tail = (LIST_T *) malloc(sizeof(LIST_T));
+  if (tail == NULL) perror("failed to allocate new element: ");
+  while (ptr->next != NULL) ptr = ptr->next;
+  tail->elem = element;
+  tail->next = NULL;
+  ptr->next = tail;
+}
+
+BLIST* create_list(BIND *binding, BLIST *second) {
+  BLIST *head = (BLIST*) malloc(sizeof(BLIST));
+  if (head == NULL) {
+    perror("Failed to create list: ");
+    exit(1);
+  }
+  head->binding = binding;
+  head->next = second;
+  return head;
+}
+
+ENV* create_new_function_env(ENV* env) {
+  ENV* n_env = (ENV*) malloc(sizeof(ENV));
+  if (n_env == NULL) {
+    perror("Failed to create environment");
+    exit(1);
+  }
+  n_env->bindings = NULL;
+  n_env->parent = env;
+  return n_env;
+}
+
+BIND* create_binding(char* name, NODE* tree, ENV* env_ptr) {
+  BIND* n_bind = (BIND*) malloc(sizeof(BIND));
+  if (n_bind == NULL) {
+    perror("Failed to create binding: ");
+    exit(1);
+  }
+  n_bind->name = name;
+  n_bind->tree = tree;
+  n_bind->env  = env_ptr;
+
+  return n_bind;
+}
+
+void append_list(BLIST *head, BIND *binding) {
+  BLIST *ptr = head;
+  while (ptr->next != NULL) {
+    ptr = ptr->next;
+  }
+  ptr->next = create_list(binding, NULL);
+}
+
+BIND* find_name_in_list(char* name, BLIST *head) {
+  BLIST *ptr = head;
+  while (ptr != NULL) {
+    if (strcmp(ptr->binding->name, name) == 0) {
+      return ptr->binding;
+    }
+    ptr = ptr->next;
+  }
+  return NULL;
+}
+
+  BIND* find_name_in_env(char* name, ENV* env) {
+    BIND* ptr = NULL;
+    ENV* env_ptr = env;
+    while (env_ptr != NULL && 
+        (ptr = find_name_in_list(name, env_ptr->bindings)) == NULL) env_ptr = env_ptr->parent;
+  return ptr;
+}
+
+TLIST* new_tac_list(TAC_T* elem, TLIST* second) {
+  TLIST *head = (TLIST*) malloc(sizeof(TLIST));
+  if (head == NULL) {
+    perror("Failed to create list: ");
+    exit(1);
+  }
+  head->elem = elem;
+  head->next = second;
+  return head;
+}
+
+TAC_T* create_tac(int op, TOKEN* src, TOKEN* tgt, TOKEN* dst) {
+  TAC_T* new_t = (TAC_T*) malloc(sizeof(TAC_T));
+  if (new_t == NULL) {
+    perror("Failed to create tac: ");
+    exit(1);
+  }
+  new_t->op  = op;
+  new_t->src = src;
+  new_t->tgt = tgt;
+  new_t->dst = dst;
+  return new_t;
+}
+
+void add_tac(TLIST *head, int op, TOKEN* src, TOKEN* tgt, TOKEN* dst) {
+  TLIST *ptr = head;
+  while (ptr->next != NULL) {
+    ptr = ptr->next;
+  }
+  ptr->next = (TLIST*) malloc(sizeof(TLIST));
+  if (ptr->next == NULL) {
+    perror("Failed to create new tac_element: ");
+    exit(1);
+  }
+  ptr->next->elem = create_tac(op, src, tgt, dst);
+  ptr->next->next = NULL;
+}
+

tac/list.h

@@ -0,0 +1,15 @@
+#ifndef LIST_H
+#define LIST_H
+#include "types.h"
+
+BLIST* create_list(BIND*, BLIST*);
+BIND* create_binding(char*, NODE*, ENV*);
+void append_list(BLIST*, BIND*);
+BIND* find_name_in_list(char*, BLIST*);
+BIND* find_name_in_env(char*, ENV*);
+ENV* create_new_function_env(ENV*);
+void add_tac(TLIST*, int, TOKEN*, TOKEN*, TOKEN*);
+TAC_T* create_tac(int, TOKEN*, TOKEN*, TOKEN*);
+TLIST* new_tac_list(TAC_T*, TLIST*);
+#endif
+

tac/main.c

@@ -0,0 +1,375 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "nodes.h"
+#include "C.tab.h"
+#include "types.h"
+#include "list.h"
+
+int asprintf(char **strp, const char *fmt, ...);
+extern TOKEN* lookup_token(char*);
+
+/*
+ * Existing problems/todo:
+ * return from control block, need a "return address" to jump to -- call levels
+ * --multiple assignments `int x,y,z = 1`--
+ * new block scope for if statements?
+ * arguments for functions
+ * difference between tilde and semicolon
+ * while loops
+ * control flow `continue` and `break` linked to return address sort of? call levels
+ */
+
+TOKEN* gen_tmp(void) {
+  char* tmp;
+  static char letter = 'a';
+  static char num = 0;
+  if (num == 100) {
+    num = 0;
+    if (++letter == 'r') letter++;
+  }
+  if (letter == '{') exit(1);
+  asprintf(&tmp, "\\%c%d", letter, num);
+  num++;
+  return lookup_token(tmp);
+}
+
+char *named(int t)
+{
+    static char b[100];
+    if (isgraph(t) || t==' ') {
+      sprintf(b, "%c", t);
+      return b;
+    }
+    switch (t) {
+      default: return "???";
+    case IDENTIFIER:
+      return "id";
+    case CONSTANT:
+      return "constant";
+    case STRING_LITERAL:
+      return "string";
+    case LE_OP:
+      return "<=";
+    case GE_OP:
+      return ">=";
+    case EQ_OP:
+      return "==";
+    case NE_OP:
+      return "!=";
+    case EXTERN:
+      return "extern";
+    case AUTO:
+      return "auto";
+    case INT:
+      return "int";
+    case VOID:
+      return "void";
+    case APPLY:
+      return "apply";
+    case LEAF:
+      return "leaf";
+    case IF:
+      return "if";
+    case ELSE:
+      return "else";
+    case WHILE:
+      return "while";
+    case CONTINUE:
+      return "continue";
+    case BREAK:
+      return "break";
+    case RETURN:
+      return "return";
+    }
+}
+
+
+
+void print_leaf(NODE *tree, int level)
+{
+    TOKEN *t = (TOKEN *)tree;
+    int i;
+    for (i=0; i<level; i++) putchar(' ');
+    if (t->type == CONSTANT) printf("%d\n", t->value);
+    else if (t->type == STRING_LITERAL) printf("\"%s\"\n", t->lexeme);
+    else if (t) puts(t->lexeme);
+}
+
+void print_tree0(NODE *tree, int level)
+{
+    int i;
+    if (tree==NULL) return;
+    if (tree->type==LEAF) {
+      print_leaf(tree->left, level);
+    }
+    else {
+      for(i=0; i<level; i++) putchar(' ');
+      printf("%s\n", named(tree->type));
+
+/*       if (tree->type=='~') { */
+/*         for(i=0; i<level+2; i++) putchar(' '); */
+/*         printf("%p\n", tree->left); */
+/*       } */
+/*       else */
+        print_tree0(tree->left, level+2);
+      print_tree0(tree->right, level+2);
+    }
+}
+
+void print_tree(NODE *tree)
+{
+    print_tree0(tree, 0);
+}
+
+// void add_function_to_env(NODE *tree, ENV *env_ptr) {
+//   BIND* existing;
+//   NODE* func_name = tree->left->right->left->left;
+//   TOKEN* name_token = (TOKEN*) func_name;
+//   if ((existing = find_name_in_env(name_token->lexeme, env_ptr)) == NULL) {
+//     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->lexeme, tree, env_ptr), NULL);
+//     } else {
+//       append_list(env_ptr->bindings, create_binding(name_token->lexeme, 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;
+//   }
+// }
+
+
+// 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(INT);
+//   tok->value = recursive_interpret(tree->right, env_ptr);
+//   asprintf(&tok->lexeme, "%d", tok->value);
+//   if ((existing = find_name_in_env(name_token->lexeme, env_ptr)) == NULL) {
+//     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->lexeme, (NODE*) tok, NULL), NULL);
+//     } else {
+//       append_list(env_ptr->bindings, create_binding(name_token->lexeme, (NODE*) tok, NULL));
+//     }
+//   } else {
+//     printf("Updating variable name %s with value: %s\n", name_token->lexeme, tok->lexeme);
+//     existing->tree = (NODE *) tok;
+//   } 
+// }
+
+void new_tac(TACS* tacs, TOKEN* dst, TOKEN* src, TOKEN* tgt, int op) {
+  if (tacs->list == NULL) {
+    TAC_T* tac;
+    tac = create_tac(op, src, tgt, dst);
+    tacs->list = new_tac_list(tac, NULL);
+  } else {
+    add_tac(tacs->list, op, src, tgt, dst);
+  }
+}
+
+char* stok(TOKEN* tok) {
+  return tok->lexeme;
+}
+
+void print_tac(TLIST* tac_list) {
+  TLIST *ptr = tac_list;
+
+  while (ptr != NULL) {
+    int op = ptr->elem->op;
+    if (op == '=') printf("%s := %s\n", stok(ptr->elem->dst), stok(ptr->elem->src));
+    if (op == '+') printf("%s := %s + %s\n", stok(ptr->elem->dst), stok(ptr->elem->src), stok(ptr->elem->tgt));
+    if (op == '-') printf("%s := %s - %s\n", stok(ptr->elem->dst), stok(ptr->elem->src), stok(ptr->elem->tgt));
+    if (op == '/') printf("%s := %s / %s\n", stok(ptr->elem->dst), stok(ptr->elem->src), stok(ptr->elem->tgt));
+    if (op == '*') printf("%s := %s * %s\n", stok(ptr->elem->dst), stok(ptr->elem->src), stok(ptr->elem->tgt));
+    if (op == '%') printf("%s := %s %% %s\n", stok(ptr->elem->dst), stok(ptr->elem->src), stok(ptr->elem->tgt));
+    if (op == RETURN) printf("ret %s\n", stok(ptr->elem->src));
+    ptr = ptr->next;
+  }
+}
+
+TOKEN* build_tac(NODE *tree, TACS* tac) {
+  if (tree == NULL) return NULL;
+  int type = tree->type;
+  if (type == LEAF) {
+    return (TOKEN *) tree->left;
+  } else if (type == '=') {
+    TOKEN* dst = (TOKEN*) tree->left->left;
+    TOKEN* result = build_tac(tree->right, tac);
+    new_tac(tac, dst, result, NULL, tree->type);
+  } else if (type=='+' || type=='-' || type=='*' || type=='/' || type =='%') {
+    TOKEN* dst = gen_tmp();
+    TOKEN* src = build_tac(tree->left, tac);
+    TOKEN* tgt = build_tac(tree->right, tac);
+    new_tac(tac, dst, src, tgt, tree->type);
+    return dst;
+  } else if (type == RETURN) {
+    TOKEN* src = build_tac(tree->left, tac);
+    new_tac(tac, NULL, src, NULL, RETURN);
+  } else {
+    build_tac(tree->left, tac);
+    build_tac(tree->right, tac);
+  }
+}
+
+
+int tmp_regs[10] = {8, 9, 10, 11, 12, 13, 14, 15, 24, 25};
+int svd_regs[8]  = {16, 17, 18, 19, 20, 21, 22, 23};
+int tmp_cntr = 0;
+VARLOC** vartab;
+
+int is_imm(TOKEN *t) {
+  if (t->type==CONSTANT) return 1;
+  else return 0;
+}
+
+int find_var_idx(TOKEN* var) {
+  int i;
+  for (i = 0; i < 8; i++) { 
+    if (vartab[i]->var == var) {
+      return vartab[i]->loc_idx;
+    }
+  }
+  return -1;
+}
+
+int store_var(TOKEN* name) {
+  int i;
+  for (i = 0; i < 8; i++) {
+    if (vartab[i]->var == NULL) {
+      vartab[i]->var = name;
+      vartab[i]->loc_idx = svd_regs[i];
+      return vartab[i]->loc_idx;
+    } else if (name == vartab[i]->var) {
+      vartab[i]->loc_idx = svd_regs[i];
+      return svd_regs[i];
+    }
+  }
+  printf("bugger\n");
+  exit(1);
+}
+
+void init_reg() {
+  int i;
+  vartab = (VARLOC**) malloc(8 * sizeof(VARLOC*));
+  for (i = 0; i < 8; i++) {
+    vartab[i] = (VARLOC*) malloc(sizeof(VARLOC));
+    vartab[i]->var = NULL;
+    vartab[i]->loc_idx = -1;
+  }
+}
+
+int alloc_register(TOKEN* val) {
+  int idx;
+  int imm = is_imm(val);
+  if (imm) {
+    if (val->value <= 32767 && val->value >= -32767) {
+      printf("ori $%d, $0, %d\n", tmp_regs[tmp_cntr], val->value);
+      idx = tmp_regs[tmp_cntr++];
+    } else {
+      printf("li $%d, %d\n", tmp_regs[tmp_cntr], val->value);
+      idx = tmp_regs[tmp_cntr++];
+    }
+  } else {
+    idx = find_var_idx(val);
+  }
+  if (tmp_cntr == 10) tmp_cntr = 0;
+  return idx;
+}
+
+void compile_tac(TLIST* tacs) {
+  printf("=====\n");
+  printf("main:\n");
+  init_reg();
+  while(tacs != NULL) {
+    TAC_T* t = tacs->elem;
+    if (t->op == '=') {
+      int src_idx = alloc_register(t->src);
+      printf("or $%d, $0, $%d\n", store_var(t->dst), src_idx);
+    }
+    if (t->op == '+') {
+      int tgt_idx = alloc_register(t->tgt);
+      int src_idx = alloc_register(t->src);
+      printf("add $%d, $%d, $%d\n", store_var(t->dst), src_idx, tgt_idx);
+    }
+    if (t->op == '-') {
+      int tgt_idx = alloc_register(t->tgt);
+      int src_idx = alloc_register(t->src);
+      printf("sub $%d, $%d, $%d\n", store_var(t->dst), src_idx, tgt_idx);
+    }
+    if (t->op == '*') {
+      int tgt_idx = alloc_register(t->tgt);
+      int src_idx = alloc_register(t->src);
+      printf("mult $%d, $%d\n", src_idx, tgt_idx);
+      printf("mflo $%d\n", store_var(t->dst));
+    }
+    if (t->op == '/') {
+      int tgt_idx = alloc_register(t->tgt);
+      int src_idx = alloc_register(t->src);
+      printf("div $%d, $%d\n", src_idx, tgt_idx);
+      printf("mflo $%d\n", store_var(t->dst));
+    }
+    if (t->op == '%') {
+      int tgt_idx = alloc_register(t->tgt);
+      int src_idx = alloc_register(t->src);
+      printf("div $%d, $%d\n", src_idx, tgt_idx);
+      printf("mfhi $%d\n", store_var(t->dst));
+    }
+    if (t->op == RETURN) {
+      int src_idx = alloc_register(t->src);
+      printf("or $k0, $0, $%d\n", src_idx);
+    }
+    tacs = tacs->next;
+  }
+  printf("ori $v0, 10\n");
+  printf("syscall\n");
+}
+
+// ENV* cons_global_env(NODE *tree) {
+//   ENV* global = create_new_function_env(NULL);
+//   recursive_interpret(tree, global);
+//   return global;
+// }
+
+void interpret_tree(NODE *tree) {
+  // ENV* global_env = cons_global_env(tree);
+  // BIND* ref_main = find_name_in_env("main", global_env);
+  // if (ref_main == NULL) {
+  //   printf("Could not find main, cannot run!\n");
+  //   exit(1);
+  // }
+  // print ref_main to make sure we really got it
+  // printf("Located %s, ready to run!\n", ref_main->name);
+  // printf("%d\n", recursive_interpret(ref_main->tree->right, ref_main->env));
+  TACS* gen_tac = (TACS*) malloc(sizeof(TACS));
+  build_tac(tree, gen_tac);
+  print_tac(gen_tac->list);
+  compile_tac(gen_tac->list);
+}
+
+extern int yydebug;
+/* extern NODE* yyparse(void); */
+extern NODE* ans;
+extern void init_symbtable(void);
+
+int main(int argc, char** argv)
+{
+    NODE* tree;
+    if (argc>1 && strcmp(argv[1],"-d")==0) yydebug = 1;
+    init_symbtable();
+    printf("--C COMPILER\n");
+    yyparse();
+    tree = ans;
+    printf("parse finished\n");
+    print_tree(tree);
+    interpret_tree(tree);
+    // int i;
+    // for (i = 0; i < 2600; i++) printf("%s\n", gen_tmp());
+    return 0;
+}

tac/nodes.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "nodes.h"
+#include "C.tab.h"
+
+NODE* make_node(int t, NODE* left, NODE* right)
+{
+    NODE *a = (NODE*)malloc(sizeof(NODE));
+    if (a==NULL) {
+      perror("Cannot make node");
+      exit(1);
+    }
+    a->type = t;
+    a->left = left;
+    a->right = right;
+    return a;
+}
+
+NODE* make_leaf(TOKEN* l)
+{
+    NODE *a = (NODE*)malloc(sizeof(NODE));
+/*     printf("make_leaf: %p -> %p\n", l, a); */
+    if (a==NULL) {
+      perror("Cannot make leaf");
+      exit(1);
+    }
+    a->type = LEAF;
+    a->left = (NODE*)l;
+    a->right = NULL;
+    return a;
+}

tac/nodes.h

@@ -0,0 +1,13 @@
+#ifndef NODES_H
+#define NODES_H
+#include "token.h"
+
+typedef struct node {
+  int          type;
+  struct node *left;
+  struct node *right;
+} NODE;
+
+NODE* make_leaf(TOKEN*);
+NODE* make_node(int, NODE*, NODE*);
+#endif

tac/prog.c

@@ -0,0 +1,11 @@
+int main() {
+  int a = 1;
+  int d = 1;
+
+  return 1;
+}
+
+int other_f() {
+  int b = 2;
+  return 2;
+}

tac/simple.c

@@ -0,0 +1,6 @@
+int main() {
+  int z = 5;
+  int y = 5 + 2;
+  int x = 5 + y * z;
+  return x;
+}

tac/symbol_table.c

@@ -0,0 +1,58 @@
+/*
+ * Adapted from 
+ * CM20029 Coursework Assignment 1
+ * Tom Crick
+ * cs1tc@bath.ac.uk
+ * 30 Apr 2003
+ *
+ * symbol_table.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "token.h"
+#include "C.tab.h"
+
+static TOKEN** symbtable;
+#define HASH_SIZE (1000)
+TOKEN *int_token, *void_token, *function_token;
+
+void init_symbtable(void)
+{
+    symbtable = (TOKEN**)calloc(HASH_SIZE, sizeof(TOKEN*));
+    int_token = new_token(INT);
+    int_token->lexeme = "int";
+    function_token = new_token(FUNCTION);
+    function_token->lexeme = "function";
+    void_token = new_token(VOID);
+    void_token->lexeme = "void";
+}
+
+int hash(char *s)
+{
+    int h = 0;
+    while (*s != '\0') {
+      h = (h<<4) ^ *s++;
+    }
+    return (0x7fffffff&h) % HASH_SIZE;
+}
+
+TOKEN* lookup_token(char *s)
+{
+    int	h = hash(s);
+    TOKEN *a = symbtable[h];
+    TOKEN *ans;
+/*     printf("\nLookup: %s\n", s); */
+    while (a!=NULL) {
+      if (strcmp(a->lexeme, s)==0) return a;
+      a = a->next;
+    }
+    ans = new_token(IDENTIFIER);
+    ans->lexeme = (char*)malloc(1+strlen(s));
+    strcpy(ans->lexeme, s);
+    ans->next = symbtable[h];
+    symbtable[h] = ans;
+/*     printf(" stored at %p\n", ans); */
+    return ans;
+}

tac/test.asm

@@ -0,0 +1,18 @@
+main:
+ori $8, $0, 2
+li $9, 48282
+add $19, $9, $8
+ori $10, $0, 2
+mult $19, $10
+mflo $20
+ori $11, $0, 2
+ori $12, $0, 4
+div $12, $11
+mflo $21
+ori $13, $0, 5
+div $13, $21
+mfhi $22
+sub $23, $20, $22
+or $k0, $0, $23
+ori $v0, 10
+syscall

tac/token.h

@@ -0,0 +1,18 @@
+#ifndef __TOKEN_H
+#define __TOKEN_H
+
+#define TRUE 1
+#define FALSE 0
+#define TEST_MODE 0
+
+typedef struct TOKEN
+{
+  int           type;
+  char          *lexeme;
+  int           value;
+  struct TOKEN  *next;
+} TOKEN;
+
+extern TOKEN* new_token(int);
+
+#endif

tac/types.h

@@ -0,0 +1,47 @@
+#ifndef TYPES_H
+#define TYPES_H
+#include "nodes.h"
+
+typedef struct binding {
+  char* name;
+  NODE* tree;
+  struct environ *env;
+} BIND;
+
+typedef struct blist {
+  BIND* binding;
+  struct blist *next;
+} BLIST;
+
+typedef struct environ {
+  BLIST *bindings;
+  struct environ *parent;
+} ENV;
+
+typedef struct tac_elem {
+  TOKEN* src;
+  TOKEN* dst;
+  TOKEN* tgt;
+  int op;
+} TAC_T;
+
+typedef struct tac_list {
+  TAC_T* elem;
+  struct tac_list* next;
+} TLIST;
+
+typedef struct tacs {
+  TLIST* list;
+} TACS;
+
+typedef struct reg {
+  int num;
+  int stored;
+} REG;
+
+typedef struct varloc {
+  TOKEN* var;
+  int loc_idx;
+} VARLOC;
+
+#endif