Improve compiling engine

parser/parser-expressions.c

@@ -73,6 +73,7 @@ TERM* parsekeyword(PARSER* p) {
 
 TERM* parseunaryopterm(PARSER* p) {
 	TERM* t = mkterm(unaryopterm);
+	t->unaryop = p->current->token[0];
 	next(p);
 	t->expression = parseterm(p);
 	t->expression->next = NULL;
@@ -92,7 +93,7 @@ TERM* parsecalltermnullified(PARSER* p) {
 	if(call == NULL)
 		return NULL;
 	TERM* t = mkterm(subroutcall);
-	t->call == call;
+	t->call = call;
 	return t;
 }
 

parser/parser-statements.c

@@ -3,7 +3,7 @@
 #include "parser-internal.h"
 #include "parser-statements.h"
 
-STATEMENT* mkstatement(STATEMENTTYPE t);
+STATEMENT* mkstatement(PARSER* p, STATEMENTTYPE t);
 STATEMENT* parsestatementnullified(PARSER* p);
 STATEMENT* parselet(PARSER* p);
 CONDSTATEMENT* parsecond(PARSER* p);
@@ -12,9 +12,10 @@ STATEMENT* parsewhile(PARSER* p);
 STATEMENT* parsedo(PARSER* p);
 STATEMENT* parsereturn(PARSER* p);
 
-STATEMENT* mkstatement(STATEMENTTYPE t) {
+STATEMENT* mkstatement(PARSER* p, STATEMENTTYPE t) {
 	STATEMENT* s = (STATEMENT*)malloc(sizeof(STATEMENT));
 	s->type = t;
+	s->debug = getdebug(p);
 	return s;
 }
 
@@ -43,8 +44,8 @@ STATEMENT* parsestatements(PARSER* p) {
 
 STATEMENT* parselet(PARSER* p) {
 	next(p);
-	STATEMENT* s = mkstatement(letstatement);
-	LETSTATEMENT* letst= (LETSTATEMENT*)malloc(sizeof(LETSTATEMENT));
+	STATEMENT* s = mkstatement(p, letstatement);
+	LETSTATEMENT* letst = (LETSTATEMENT*)malloc(sizeof(LETSTATEMENT));
 
 	letst->varname = parseidentifier(p);
 	
@@ -63,6 +64,7 @@ STATEMENT* parselet(PARSER* p) {
 	checkcontent(p, ";");
 
 	s->type = letstatement;
+	s->letstatement = letst;
 	return s;
 }
 
@@ -84,7 +86,7 @@ CONDSTATEMENT* parsecond(PARSER* p) {
 
 STATEMENT* parseif(PARSER* p) {
 	next(p);
-	STATEMENT* s = mkstatement(ifstatement);
+	STATEMENT* s = mkstatement(p, ifstatement);
 	IFSTATEMENT* ifst = (IFSTATEMENT*)malloc(sizeof(IFSTATEMENT));
 
 	ifst->base = parsecond(p);
@@ -99,12 +101,13 @@ STATEMENT* parseif(PARSER* p) {
 		ifst->elsestatements = NULL;
 
 	s->type = ifstatement;
+	s->ifstatement = ifst;
 	return s;
 }
 
 STATEMENT* parsewhile(PARSER* p) {
 	next(p);
-	STATEMENT* s = mkstatement(whilestatement);
+	STATEMENT* s = mkstatement(p, whilestatement);
 
 	s->whilestatement = parsecond(p);
 	return s;
@@ -112,7 +115,7 @@ STATEMENT* parsewhile(PARSER* p) {
 
 STATEMENT* parsedo(PARSER* p) {
 	next(p);
-	STATEMENT* s = mkstatement(dostatement);
+	STATEMENT* s = mkstatement(p, dostatement);
 
 	s->dostatement = parsesubroutcall(p);
 
@@ -122,7 +125,7 @@ STATEMENT* parsedo(PARSER* p) {
 
 STATEMENT* parsereturn(PARSER* p) {
 	next(p);
-	STATEMENT* s = mkstatement(returnstatement);
+	STATEMENT* s = mkstatement(p, returnstatement);
 
 	s->retstatement = parseexpressionnullified(p);
 

parser/parser-structure.c

@@ -60,7 +60,7 @@ CLASS* parseclasses(PARSER* p) {
 
 int parsepossibilities(PARSER* p, STRINGARRAY* poss) {
 	for(int i = 0; i < poss->size; i++)
-		if(!strcmp(p->current->token, poss->items[i]))
+		if(equals(p, poss->items[i]))
 			return i;
 	return -1;
 }
@@ -87,14 +87,9 @@ CLASSVARDEC* parseclassvardec(PARSER* p) {
 
 CLASSVARDEC* parseclassvardecs(PARSER* p) {
 	CLASSVARDEC* head = parseclassvardec(p);
-	if(head != NULL)
-		head->base->index = 0;
-	int index = 1;
 	CLASSVARDEC* curr = head;
 	CLASSVARDEC* nextc;
 	while(nextc = parseclassvardec(p), nextc != NULL) {
-		nextc->base->index = index;
-		index++;
 		curr->next = nextc;
 		curr = nextc;
 	}
@@ -156,6 +151,7 @@ PARAMETER* parseparameter(PARSER* p) {
 	if(equals(p, ")"))
 		return NULL;
 	param->debug = getdebug(p);
+	param->primitive = isprimitive(p->current);
 	param->type = parsetype(p);
 	param->name = parseidentifier(p);
 	return param;
@@ -163,9 +159,6 @@ PARAMETER* parseparameter(PARSER* p) {
 
 PARAMETER* parseparameters(PARSER* p) {
 	PARAMETER* head = parseparameter(p);
-	if(head != NULL)
-		head->index = 0;
-	int index = 1;
 	PARAMETER* curr = head;
 	PARAMETER* nextp;
 	while(equals(p, ",")) {
@@ -173,9 +166,7 @@ PARAMETER* parseparameters(PARSER* p) {
 		nextp = parseparameter(p);
 		if(nextp == NULL)
 			unexpected(p);
-		nextp->index = index;
 		curr->next = nextp;
-		index++;
 		curr = curr->next;
 	}
 	if(curr != NULL)
@@ -199,7 +190,7 @@ bool isprimitive(TOKEN* tk) {
 }
 
 char* parsetype(PARSER* p) {
-	if(p->current->type != identifier)
+	if(p->current->type != identifier && p->current->type != keyword)
 		unexpected(p);
 
 	char* result = p->current->token;
@@ -246,15 +237,10 @@ VARDEC* parsevardec(PARSER* p) {
 
 VARDEC* parsevardecs(PARSER* p) {
 	VARDEC* head = parsevardec(p);
-	if(head != NULL)
-		head->index = 0;
-	int index = 1;
 	VARDEC* curr = head;
 	VARDEC* nextv;
 	while(nextv = parsevardec(p), nextv != NULL) {
-		nextv->index = index;
-		index++;
-		curr->next = nextv;
+			curr->next = nextv;
 		curr = nextv;
 	}
 	if(curr != NULL)

parser/parser-tree.h

@@ -60,7 +60,7 @@ typedef struct subroutdec {
 typedef struct parameter {
 	char* type;
 	char* name;
-	int index;
+	bool primitive;
 	DEBUGINFO* debug;
 	struct parameter* next;
 } PARAMETER;
@@ -73,7 +73,6 @@ typedef struct subroutbody {
 typedef struct vardec {
 	char* type;
 	bool primitive;
-	int index;
 	TOKENTYPE typeclass;
 	STRINGLIST* names;
 	DEBUGINFO* debug;
@@ -94,6 +93,7 @@ typedef struct statement {
 		struct subroutcall* dostatement;
 		struct term* retstatement;
 	};
+	DEBUGINFO* debug;
 	struct statement* next;
 } STATEMENT;
 
@@ -129,6 +129,7 @@ typedef struct term {
 	};
 	struct term* arrayexp;
 	char op;
+	char unaryop;
 	struct term* next;
 } TERM;