Fix segfault

Makefile

@@ -1,7 +1,7 @@
 FILES = *.c */*.c
 LIBRARIES = -lpthread
 INCLUDES = -I. -I./parser/ -I./compiler/ -I./vm/ -I./tokenizer/ -I./misc/
-CFLAGS = -std=c99 -Wall
+CFLAGS = -std=c99 -Wall -O3
 OUTFILE = jack-compiler
 
 main: ${FILES}

compiler/compiler-expressions.c

@@ -15,10 +15,10 @@ char* toascii(char c);
 // Dealing with singular terms
 LINEBLOCK* compilestrconst(char* str);
 LINEBLOCK* compilekeywordconst(SCOPE* s, TERM* t);
-LINEBLOCK* compilearrayitem(SCOPE* s, TERM* t);
+LINEBLOCK* compilearrayitem(SCOPE* s, DEBUGINFO* d, TERM* t);
 LINEBLOCK* compilecallln(SCOPE* s, SUBROUTDEC* d, SUBROUTCALL* call);
-LINEBLOCK* pushunaryopterm(SCOPE* s, TERM* t);
-LINEBLOCK* compileterm(SCOPE* s, TERM* t);
+LINEBLOCK* pushunaryopterm(SCOPE* s, DEBUGINFO* d, TERM* t);
+LINEBLOCK* compileterm(SCOPE* s, DEBUGINFO* d, TERM* t);
 
 /* END FORWARD DECLARATIONS */
 
@@ -128,9 +128,9 @@ LINEBLOCK* compilekeywordconst(SCOPE* s, TERM* t) {
 	return mklnblk(pushconstant(0));
 }
 
-LINEBLOCK* compilearrayitem(SCOPE* s, TERM* t) {
-	LINEBLOCK* blk = compileexpression(s, t->array->exp);
-	appendln(blk, pushvar(s, t->array->name));
+LINEBLOCK* compilearrayitem(SCOPE* s, DEBUGINFO* d, TERM* t) {
+	LINEBLOCK* blk = compileexpression(s, d, t->array->exp);
+	appendln(blk, pushvar(s, d, t->array->name));
 
 	appendln(blk, onetoken("add"));
 
@@ -161,7 +161,7 @@ LINEBLOCK* compilesubroutcall(SCOPE* s, SUBROUTCALL* call) {
 	LINEBLOCK* blk = compilecallln(s, d, call);
 
 	if(call->parameters != NULL)
-		blk = mergelnblks(compileexplist(s, call->parameters), blk);
+		blk = mergelnblks(compileexplist(s, call->debug, call->parameters), blk);
 
 	if(d->subroutclass == method) {
 		if(call->parentname == NULL)
@@ -179,8 +179,8 @@ LINEBLOCK* compilesubroutcall(SCOPE* s, SUBROUTCALL* call) {
 	return blk;
 }
 
-LINEBLOCK* pushunaryopterm(SCOPE* s, TERM* t) {
-	LINEBLOCK* blk = compileexpression(s, t->expression);
+LINEBLOCK* pushunaryopterm(SCOPE* s, DEBUGINFO* d, TERM* t) {
+	LINEBLOCK* blk = compileexpression(s, d, t->expression);
 	LINE* neg;
 	if(t->unaryop == '-')
 	       	neg = onetoken("neg");
@@ -190,36 +190,39 @@ LINEBLOCK* pushunaryopterm(SCOPE* s, TERM* t) {
 	return blk;
 }
 
-LINEBLOCK* compileterm(SCOPE* s, TERM* t) {
-	if(t->type == varname) return mklnblk(pushvar(s, t->string));
+LINEBLOCK* compileterm(SCOPE* s, DEBUGINFO* d, TERM* t) {
+	if(t->type == varname) return mklnblk(pushvar(s, d, t->string));
 	if(t->type == intconstant) return mklnblk(pushconstant(t->integer));
 	if(t->type == stringconstant) return compilestrconst(t->string);
 	if(t->type == keywordconstant) return compilekeywordconst(s, t);
-	if(t->type == arrayitem) return compilearrayitem(s, t);
+	if(t->type == arrayitem) return compilearrayitem(s, d, t);
 	if(t->type == subroutcall) return compilesubroutcall(s, t->call);
-	if(t->type == innerexpression) return compileexpression(s, t->expression);
-	return pushunaryopterm(s, t);
+	if(t->type == innerexpression) return compileexpression(s, d, t->expression);
+	return pushunaryopterm(s, d, t);
 }
 
 // Dealing with whole expressions
-LINEBLOCK* compileexpression(SCOPE* s, TERM* e) {
+LINEBLOCK* compileexpression(SCOPE* s, DEBUGINFO* d, TERM* e) {
 	LINEBLOCK* blk = NULL;
+	LINEBLOCK* ops = NULL;
 	if(e != NULL) {
 		while(true) {
-			blk = mergelnblks(blk, compileterm(s, e));
+			blk = mergelnblks(blk, compileterm(s, d, e));
 			if(e->next == NULL)
 				break;
-			appendln(blk, mathopln(e->op));
+			ops = mergelnblks(ops, mklnblk(mathopln(e->op)));
 			e = e->next;
 		}
 	}
+	if(ops != NULL)
+		blk = mergelnblks(blk, ops);
 	return blk;
 }
 
-LINEBLOCK* compileexplist(SCOPE* s, EXPRESSIONLIST* explist) {
+LINEBLOCK* compileexplist(SCOPE* s, DEBUGINFO* d, EXPRESSIONLIST* explist) {
 	LINEBLOCK* head = NULL;
 	while(explist != NULL) {
-		head = mergelnblks(head, compileexpression(s, explist->expression));
+		head = mergelnblks(head, compileexpression(s, d, explist->expression));
 		explist = explist->next;
 	}
 	return head;

compiler/compiler-expressions.h

@@ -10,6 +10,6 @@
 LINEBLOCK* compilesubroutcall(SCOPE* s, SUBROUTCALL* call);
 
 // Dealing with whole expressions
-LINEBLOCK* compileexpression(SCOPE* s, TERM* e);
-LINEBLOCK* compileexplist(SCOPE* s, EXPRESSIONLIST* explist);
+LINEBLOCK* compileexpression(SCOPE* s, DEBUGINFO* d, TERM* e);
+LINEBLOCK* compileexplist(SCOPE* s, DEBUGINFO* d, EXPRESSIONLIST* explist);
 #endif

compiler/compiler-scopes.c

@@ -11,7 +11,7 @@ char* memsegnames[] = { "local", "static", "argument", "this" };
 
 // Error messages
 void doubledeclaration(const char* name, DEBUGINFO* d1, DEBUGINFO* d2);
-void ensurenoduplicate(SCOPE* s, char* name);
+void ensurenoduplicate(SCOPE* s, DEBUGINFO* d, char* name);
 
 // Getters
 VAR* getvarinvars(VAR* vars, const char* name);
@@ -49,18 +49,18 @@ void invalidparent(SUBROUTCALL* call) {
 	exit(1);
 }
 
-void ensurenoduplicate(SCOPE* s, char* name) {
+void ensurenoduplicate(SCOPE* s, DEBUGINFO* d, char* name) {
 	VAR* v = getvar(s, name);
 	if(v != NULL)
-		doubledeclaration(name, s->currdebug, v->debug);
+		doubledeclaration(name, d, v->debug);
 
 	CLASS* c = getclass(s, name);
 	if(c != NULL)
-		doubledeclaration(name, s->currdebug, c->debug);
+		doubledeclaration(name, d, c->debug);
 
 	SUBROUTDEC* sr = getsubroutdec(s, name);
 	if(sr != NULL)
-		doubledeclaration(name, s->currdebug, sr->debug);
+		doubledeclaration(name, d, sr->debug);
 }
 
 // Scope handling
@@ -106,6 +106,13 @@ VAR* getvar(SCOPE* s, const char* name) {
 	return NULL;
 }
 
+VAR* getvarmustexist(SCOPE* s, DEBUGINFO* d, const char* name) {
+	VAR* v = getvar(s, name);
+	if(v == NULL)
+		notdeclared(name, d);
+	return v;
+}
+
 CLASS* getclass(SCOPE* s, const char* name) {
 	CLASS* curr = s->classes;
 	while(curr != NULL) {
@@ -213,7 +220,7 @@ VAR* mkvar(char* type, char* name, bool primitive, DEBUGINFO* debug, MEMSEGMENT
 }
 
 void addvar(SCOPE* s, VAR** dest, VAR* v) {
-	ensurenoduplicate(s, v->name);
+	ensurenoduplicate(s, v->debug, v->name);
 
 	if(!v->primitive) {
 		CLASS* type = getclass(s, v->type);

compiler/compiler-scopes.h

@@ -22,7 +22,6 @@ typedef struct var {
 
 typedef struct scope {
 	struct compiler* compiler;
-	DEBUGINFO* currdebug;
 	CLASS* currclass;
 
 	CLASS* classes;
@@ -52,6 +51,7 @@ CLASS* getclass(SCOPE* s, const char* name);
 
 // Generic getters
 VAR* getvar(SCOPE* s, const char* name);
+VAR* getvarmustexist(SCOPE* s, DEBUGINFO* d, const char* name);
 
 // Freeing
 void freescope(SCOPE* s);

compiler/compiler-statements.c

@@ -12,10 +12,10 @@ LINE* pushtemp();
 char* mkcondlabel(char* name, int count);
 
 // Handling individual statements
-LINEBLOCK* compileret(SCOPE* s, TERM* e);
-LINEBLOCK* compileif(SCOPE* s, IFSTATEMENT* st);
-LINEBLOCK* compilewhile(SCOPE* s, CONDSTATEMENT* w);
-LINEBLOCK* compilelet(SCOPE* s, LETSTATEMENT* l);
+LINEBLOCK* compileret(SCOPE* s, STATEMENT* st);
+LINEBLOCK* compileif(SCOPE* s, STATEMENT* st);
+LINEBLOCK* compilewhile(SCOPE* s, STATEMENT* st);
+LINEBLOCK* compilelet(SCOPE* s, STATEMENT* st);
 LINEBLOCK* compilestatement(SCOPE* s, STATEMENT* st);
 
 /* END FORWARD DECLARATIONS */
@@ -41,7 +41,8 @@ char* mkcondlabel(char* name, int count) {
 }
 
 // Handling individual statements
-LINEBLOCK* compileret(SCOPE* s, TERM* e) {
+LINEBLOCK* compileret(SCOPE* s, STATEMENT* st) {
+	TERM* e = st->retstatement;
 	LINE* ret = onetoken("return");
 	LINEBLOCK* blk = mklnblk(ret);
 
@@ -50,13 +51,14 @@ LINEBLOCK* compileret(SCOPE* s, TERM* e) {
 		char* tokens[] = { "push", "constant", "0" };
 		appendlnbefore(blk, mkln(tokens));
 	} else
-		blk = mergelnblks(compileexpression(s, e), blk);
+		blk = mergelnblks(compileexpression(s, st->debug, e), blk);
 
 	return blk;
 }
 
-LINEBLOCK* compileif(SCOPE* s, IFSTATEMENT* st) {
-	LINEBLOCK* blk = compileexpression(s, st->base->expression);
+LINEBLOCK* compileif(SCOPE* s, STATEMENT* st) {
+	IFSTATEMENT* ifst = st->ifstatement;
+	LINEBLOCK* blk = compileexpression(s, st->debug, ifst->base->expression);
 
 	pthread_mutex_lock(&(s->compiler->ifmutex));
 	static int ifcount = 0;
@@ -75,10 +77,10 @@ LINEBLOCK* compileif(SCOPE* s, IFSTATEMENT* st) {
 	char* truelabelln[] = { "label", truelabel };
 	appendln(blk, mkln(truelabelln));
 
-	blk = mergelnblks(blk, compilestatements(s, st->base->statements));
+	blk = mergelnblks(blk, compilestatements(s, ifst->base->statements));
 
 	char* endlabel;
-	bool haselse = st->elsestatements != NULL;
+	bool haselse = ifst->elsestatements != NULL;
 	if(haselse) {
 		endlabel = mkcondlabel("IF_END", mycount);
 		char* endgoto[] = { "goto", endlabel };
@@ -89,7 +91,7 @@ LINEBLOCK* compileif(SCOPE* s, IFSTATEMENT* st) {
 	appendln(blk, mkln(falselabelln));
 
 	if(haselse) {
-		blk = mergelnblks(blk, compilestatements(s, st->elsestatements));
+		blk = mergelnblks(blk, compilestatements(s, ifst->elsestatements));
 		char* endlabelln[] = { "label", endlabel };
 		appendln(blk, mkln(endlabelln));
 		free(endlabel);
@@ -101,8 +103,9 @@ LINEBLOCK* compileif(SCOPE* s, IFSTATEMENT* st) {
 	return blk;
 }
 
-LINEBLOCK* compilewhile(SCOPE* s, CONDSTATEMENT* w) {
-	LINEBLOCK* blk = compileexpression(s, w->expression);
+LINEBLOCK* compilewhile(SCOPE* s, STATEMENT* st) {
+	CONDSTATEMENT* w = st->whilestatement;
+	LINEBLOCK* blk = compileexpression(s, st->debug, w->expression);
 
 	pthread_mutex_lock(&(s->compiler->whilemutex));
 	static int whilecount = 0;
@@ -134,13 +137,14 @@ LINEBLOCK* compilewhile(SCOPE* s, CONDSTATEMENT* w) {
 	return blk;
 }
 
-LINEBLOCK* compilelet(SCOPE* s, LETSTATEMENT* l) {
-	LINEBLOCK* blk = compileexpression(s, l->expression);
+LINEBLOCK* compilelet(SCOPE* s, STATEMENT* st) {
+	LETSTATEMENT* l = st->letstatement;
+	LINEBLOCK* blk = compileexpression(s, st->debug, l->expression);
 
 	if(l->arrayind != NULL) {
 		appendlnbefore(blk, onetoken("add"));
-		appendlnbefore(blk, pushvar(s, l->varname));
-		blk = mergelnblks(compileexpression(s, l->arrayind), blk);
+		appendlnbefore(blk, pushvar(s, st->debug, l->varname));
+		blk = mergelnblks(compileexpression(s, st->debug, l->arrayind), blk);
 
 		appendln(blk, poptemp());
 		appendln(blk, popthatadd());
@@ -148,17 +152,16 @@ LINEBLOCK* compilelet(SCOPE* s, LETSTATEMENT* l) {
 		appendln(blk, popthat());
 	}
 	else
-		appendln(blk, popvar(s, l->varname));
+		appendln(blk, popvar(s, st->debug, l->varname));
 	return blk;
 }
 
 LINEBLOCK* compilestatement(SCOPE* s, STATEMENT* st) {
-	s->currdebug = st->debug;
 	if(st->type == dostatement) return compilesubroutcall(s, st->dostatement);
-	if(st->type == returnstatement) return compileret(s, st->retstatement);
-	if(st->type == ifstatement) return compileif(s, st->ifstatement);
-	if(st->type == whilestatement) return compilewhile(s, st->whilestatement);
-	return compilelet(s, st->letstatement);
+	if(st->type == returnstatement) return compileret(s, st);
+	if(st->type == ifstatement) return compileif(s, st);
+	if(st->type == whilestatement) return compilewhile(s, st);
+	return compilelet(s, st);
 }
 
 LINEBLOCK* compilestatements(SCOPE* s, STATEMENT* sts) {
@@ -169,3 +172,15 @@ LINEBLOCK* compilestatements(SCOPE* s, STATEMENT* sts) {
 	}
 	return head;
 }
+
+LINEBLOCK* compilestatementsretlast(SCOPE* s, STATEMENT* sts, STATEMENT** retlast) {
+	LINEBLOCK* head = NULL;
+	STATEMENT* last = NULL;
+	while(sts != NULL) {
+		head = mergelnblks(head, compilestatement(s, sts));
+		last = sts;
+		sts = sts->next;
+	}
+	*retlast = last;
+	return head;
+}

compiler/compiler-statements.h

@@ -6,4 +6,5 @@
  * Single function for compiling statements */
 
 LINEBLOCK* compilestatements(SCOPE* s, STATEMENT* sts);
+LINEBLOCK* compilestatementsretlast(SCOPE* s, STATEMENT* sts, STATEMENT** retlast);
 #endif

compiler/compiler-structure.c

@@ -12,7 +12,7 @@ int getobjsize(CLASS* c);
 LINE* mksubdeclabel(CLASS* c, SUBROUTDEC* sd);
 
 // Compiling methods
-LINEBLOCK* compilefunbody(SCOPE* s, CLASS* cl, SUBROUTBODY* b);
+LINEBLOCK* compilefunbody(SCOPE* s, CLASS* cl, SUBROUTDEC* d);
 LINEBLOCK* compilefundec(SCOPE* s, CLASS* cl, SUBROUTDEC* f);
 LINEBLOCK* compileconstructor(SCOPE* s, CLASS* cl, SUBROUTDEC* con);
 LINEBLOCK* compilemethod(SCOPE* s, CLASS* cl, SUBROUTDEC* m);
@@ -64,12 +64,27 @@ LINE* mksubdeclabel(CLASS* c, SUBROUTDEC* sd) {
 }
 
 // Compiling methods
-LINEBLOCK* compilefunbody(SCOPE* s, CLASS* cl, SUBROUTBODY* b) {
+LINEBLOCK* compilefunbody(SCOPE* s, CLASS* cl, SUBROUTDEC* d) {
+	SUBROUTBODY* b = d->body;
 	SCOPE* myscope = mkscope(s);
 	myscope->currclass = cl;
 	if(b->vardecs != NULL)
 		addlocalvars(myscope, b->vardecs);
-	LINEBLOCK* head = compilestatements(myscope, b->statements);
+
+	if(b->statements == NULL) {
+		eprintf("Subroutine body has no statements; file '%s', line %i\n",
+				d->debug->file, d->debug->definedat);
+		exit(1);
+	}
+
+	STATEMENT* last;
+	LINEBLOCK* head = compilestatementsretlast(myscope, b->statements, &last);
+	if(last->type != returnstatement) {
+		eprintf("Subroutine must end with a return statement; file '%s', line %i\n",
+				last->debug->file, last->debug->definedat);
+		exit(1);
+	}
+
 	freescope(myscope);
 	return head;
 }
@@ -77,13 +92,9 @@ LINEBLOCK* compilefunbody(SCOPE* s, CLASS* cl, SUBROUTBODY* b) {
 LINEBLOCK* compilefundec(SCOPE* s, CLASS* cl, SUBROUTDEC* f) {
 	LINE* label = mksubdeclabel(cl, f);
 
-	if(f->body->statements != NULL) {
-		LINEBLOCK* body = compilefunbody(s, cl, f->body);
-		appendlnbefore(body, label);
-		return body;
-	}
-	else
-		return mklnblk(label);
+	LINEBLOCK* body = compilefunbody(s, cl, f);
+	appendlnbefore(body, label);
+	return body;
 }
 
 LINEBLOCK* compileconstructor(SCOPE* s, CLASS* cl, SUBROUTDEC* con) {
@@ -99,7 +110,7 @@ LINEBLOCK* compileconstructor(SCOPE* s, CLASS* cl, SUBROUTDEC* con) {
 	free(size[2]);
 
 	if(con->body != NULL)
-		return mergelnblks(blk, compilefunbody(s, cl, con->body));
+		return mergelnblks(blk, compilefunbody(s, cl, con));
 	else
 		return blk;
 }
@@ -114,7 +125,7 @@ LINEBLOCK* compilemethod(SCOPE* s, CLASS* cl, SUBROUTDEC* m) {
 	appendln(blk, mkln(poppointer));
 
 	if(m->body != NULL) 
-		return mergelnblks(blk, compilefunbody(s, cl, m->body));
+		return mergelnblks(blk, compilefunbody(s, cl, m));
 	else
 		return blk;
 }

compiler/compiler-util.c

@@ -8,21 +8,16 @@ LINE* opvarraw(SCOPE* s, char* op, VAR* v) {
 	return ln;
 }
 
-LINE* opvar(SCOPE* s, char* op, const char* name) {
-	VAR* v = getvar(s, name);
-	return opvarraw(s, op, v);
-}
-
-LINE* pushvarraw(SCOPE*s, VAR* v) {
+LINE* pushvarraw(SCOPE* s, VAR* v) {
 	return opvarraw(s, "push", v);
 }
 
-LINE* pushvar(SCOPE* s, const char* name) {
-	return opvar(s, "push", name);
+LINE* pushvar(SCOPE* s, DEBUGINFO* d, const char* name) {
+	return opvarraw(s, "push", getvarmustexist(s, d, name));
 }
 
-LINE* popvar(SCOPE* s, const char* name) {
-	return opvar(s, "pop", name);
+LINE* popvar(SCOPE* s, DEBUGINFO* d, const char* name) {
+	return opvarraw(s, "pop", getvarmustexist(s, d, name));
 }
 
 LINE* poptemp() {

compiler/compiler-util.h

@@ -12,9 +12,9 @@
 LINE* onetoken(char* str);
 LINE* mksimpleln(char** tokens, int count);
 
-LINE* pushvarraw(SCOPE*s, VAR* v);
-LINE* pushvar(SCOPE* s, const char* name);
-LINE* popvar(SCOPE* s, const char* name);
+LINE* pushvarraw(SCOPE* s, VAR* v);
+LINE* pushvar(SCOPE* s, DEBUGINFO* d, const char* name);
+LINE* popvar(SCOPE* s, DEBUGINFO* d, const char* name);
 LINE* poptemp();
 LINE* popthatadd();