From e36d47a899189293c3c2db9eec57e3ac35d54231 Mon Sep 17 00:00:00 2001 From: Augusto Gunsch Date: Wed, 6 Jan 2021 21:18:52 -0300 Subject: [PATCH] Fix segfault --- compiler/compiler-expressions.c | 36 ++++++++++++------------- compiler/compiler-expressions.h | 4 +-- compiler/compiler-scopes.c | 7 +++++ compiler/compiler-scopes.h | 1 + compiler/compiler-statements.c | 48 ++++++++++++++++++--------------- compiler/compiler-util.c | 15 ++++------- compiler/compiler-util.h | 6 ++--- 7 files changed, 62 insertions(+), 55 deletions(-) diff --git a/compiler/compiler-expressions.c b/compiler/compiler-expressions.c index 27d4432..5e517f0 100644 --- a/compiler/compiler-expressions.c +++ b/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,23 +190,23 @@ 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; 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)); @@ -216,10 +216,10 @@ LINEBLOCK* compileexpression(SCOPE* s, TERM* e) { 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; diff --git a/compiler/compiler-expressions.h b/compiler/compiler-expressions.h index 01eccbf..059f466 100644 --- a/compiler/compiler-expressions.h +++ b/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 diff --git a/compiler/compiler-scopes.c b/compiler/compiler-scopes.c index 2af5eec..863b492 100644 --- a/compiler/compiler-scopes.c +++ b/compiler/compiler-scopes.c @@ -105,6 +105,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) { diff --git a/compiler/compiler-scopes.h b/compiler/compiler-scopes.h index 1994f77..fa3055c 100644 --- a/compiler/compiler-scopes.h +++ b/compiler/compiler-scopes.h @@ -52,6 +52,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); diff --git a/compiler/compiler-statements.c b/compiler/compiler-statements.c index 3c40a37..db2cc29 100644 --- a/compiler/compiler-statements.c +++ b/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,17 @@ 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) { diff --git a/compiler/compiler-util.c b/compiler/compiler-util.c index a699e3d..9839fe3 100644 --- a/compiler/compiler-util.c +++ b/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() { diff --git a/compiler/compiler-util.h b/compiler/compiler-util.h index 01fa4c2..f282569 100644 --- a/compiler/compiler-util.h +++ b/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();