augusto
/
jack-compiler
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix segfault

This commit is contained in:
Augusto Gunsch 2021-01-06 21:18:52 -03:00
parent 8325b067b4
commit 80a3e1ef0f
No known key found for this signature in database
GPG Key ID: F7EEFE29825C72DC
8 changed files with 63 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

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

36
compiler/compiler-expressions.c
View File

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

4
compiler/compiler-expressions.h
View File

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

7
compiler/compiler-scopes.c
View File

@ -106,6 +106,13 @@ VAR* getvar(SCOPE* s, const char* name) {
return NULL; 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* getclass(SCOPE* s, const char* name) {
CLASS* curr = s->classes; CLASS* curr = s->classes;
while(curr != NULL) { while(curr != NULL) {

1
compiler/compiler-scopes.h
View File

@ -52,6 +52,7 @@ CLASS* getclass(SCOPE* s, const char* name);
// Generic getters // Generic getters
VAR* getvar(SCOPE* s, const char* name); VAR* getvar(SCOPE* s, const char* name);
VAR* getvarmustexist(SCOPE* s, DEBUGINFO* d, const char* name);
// Freeing // Freeing
void freescope(SCOPE* s); void freescope(SCOPE* s);

48
compiler/compiler-statements.c
View File

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

15
compiler/compiler-util.c
View File

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

6
compiler/compiler-util.h
View File

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