Fix bugs, memory leaks and small fixes

parser/parser-expressions.c

@@ -166,6 +166,7 @@ TERM* parseexpression(PARSER* p) {
 }
 
 SUBROUTCALL* nullsubroutcall(PARSER* p, SUBROUTCALL* c) {
+	free(c->debug);
 	free(c);
 	rewindparser(p);
 	return NULL;

parser/parser-structure.c

@@ -167,9 +167,9 @@ SUBROUTDEC* parsesubroutdecs(PARSER* p, CLASS* c) {
 }
 
 PARAMETER* parseparameter(PARSER* p) {
-	PARAMETER* param = (PARAMETER*)malloc(sizeof(PARAMETER));
 	if(equals(p, ")"))
 		return NULL;
+	PARAMETER* param = (PARAMETER*)malloc(sizeof(PARAMETER));
 	param->debug = getdebug(p);
 	param->primitive = isprimitive(p->current);
 	param->type = parsetype(p);

parser/parser-tree.c

@@ -0,0 +1,141 @@
+#include <stdlib.h>
+#include "parser-tree.h"
+
+void freeexpression(TERM* e);
+void freeexpressionlist(EXPRESSIONLIST* el);
+void freestatements(STATEMENT* s);
+
+void freevardec(VARDEC* v) {
+	freestrlist(v->names);
+	free(v->debug);
+	free(v);
+}
+
+void freevardecs(VARDEC* v) {
+	VARDEC* next = v->next;
+	freevardec(v);
+	if(next != NULL)
+		freevardecs(next);
+}
+
+void freeparameters(PARAMETER* p) {
+	free(p->debug);
+	PARAMETER* next = p->next;
+	free(p);
+	if(next != NULL)
+		freeparameters(next);
+}
+
+void freearray(ARRAY* a) {
+	freeexpression(a->exp);
+	free(a);
+}
+
+void freesubroutcall(SUBROUTCALL* call) {
+	if(call->parameters != NULL)
+		freeexpressionlist(call->parameters);
+	free(call->debug);
+	free(call);
+}
+
+void freeexpression(TERM* e) {
+	if(e->type == arrayitem)
+		freearray(e->array);
+	else if(e->type == innerexpression || e->type == unaryopterm)
+		freeexpression(e->expression);
+	else if(e->type == subroutcall)
+		freesubroutcall(e->call);
+	TERM* next = e->next;
+	free(e);
+	if(next != NULL)
+		freeexpression(next);
+}
+
+void freeexpressionlist(EXPRESSIONLIST* el) {
+	freeexpression(el->expression);
+	EXPRESSIONLIST* next = el->next;
+	free(el);
+	if(next != NULL)
+		freeexpressionlist(next);
+}
+
+void freelet(LETSTATEMENT* l) {
+	if(l->arrayind != NULL)
+		freeexpression(l->arrayind);
+	freeexpression(l->expression);
+	free(l);
+}
+
+void freecond(CONDSTATEMENT* cond) {
+	freeexpression(cond->expression);
+	if(cond->statements != NULL)
+		freestatements(cond->statements);
+	free(cond);
+}
+
+void freeif(IFSTATEMENT* st) {
+	freecond(st->base);
+	if(st->elsestatements != NULL)
+		freestatements(st->elsestatements);
+	free(st);
+}
+
+void freestatements(STATEMENT* s) {
+	if(s->type == letstatement)
+		freelet(s->letstatement);
+	else if(s->type == ifstatement)
+		freeif(s->ifstatement);
+	else if(s->type == whilestatement)
+		freecond(s->whilestatement);
+	else if(s->type == dostatement)
+		freesubroutcall(s->dostatement);
+	else if(s->retstatement != NULL)
+		freeexpression(s->retstatement);
+
+	free(s->debug);
+	STATEMENT* next = s->next;
+	free(s);
+	if(next != NULL)
+		freestatements(next);
+}
+
+void freesubroutbody(SUBROUTBODY* b) {
+	if(b->vardecs != NULL)
+		freevardecs(b->vardecs);
+	if(b->statements != NULL)
+		freestatements(b->statements);
+	free(b);
+}
+
+void freesubroutdecs(SUBROUTDEC* sr) {
+	free(sr->debug);
+	if(sr->parameters != NULL)
+		freeparameters(sr->parameters);
+	freesubroutbody(sr->body);
+	SUBROUTDEC* next = sr->next;
+	free(sr);
+	if(next != NULL)
+		freesubroutdecs(next);
+}
+
+void freeclassvardecs(CLASSVARDEC* cvd) {
+	freevardec(cvd->base);
+	CLASSVARDEC* next = cvd->next;
+	free(cvd);
+	if(next != NULL)
+		freeclassvardecs(next);
+}
+
+void freetree(CLASS* c) {
+	free(c->debug);
+
+	if(c->vardecs != NULL)
+		freeclassvardecs(c->vardecs);
+	if(c->subroutdecs != NULL)
+		freesubroutdecs(c->subroutdecs);
+
+	CLASS* next = c->next;
+	free(c);
+	if(next != NULL)
+		freetree(next);
+}

parser/parser-tree.h

@@ -155,4 +155,6 @@ typedef struct expressionlist {
 	struct expressionlist* next;
 } EXPRESSIONLIST;
 
+
+void freetree(CLASS* c);
 #endif

parser/parser.c

@@ -5,10 +5,19 @@
 #include "parser.h"
 #include "parser-structure.h"
 
-CLASS* parse(TOKEN* tokens, char* file) {
+PARSER* mkparser(TOKEN* t, char* file) {
 	PARSER* parser = (PARSER*)malloc(sizeof(PARSER));
-	parser->tokens = tokens;
-	parser->current = tokens;
+	parser->tokens = t;
+	parser->current = t;
 	parser->file = file;
-	return parseclass(parser);
+	return parser;
+}
+
+CLASS* parse(PARSER* p) {
+	return parseclass(p);
+}
+
+void freeparser(PARSER* p) {
+	freetokens(p->tokens);
+	free(p);
 }

parser/parser.h

@@ -14,5 +14,7 @@ typedef struct {
 	char* file;
 } PARSER;
 
-CLASS* parse(TOKEN* tokens, char* file);
+PARSER* mkparser(TOKEN* t, char* file);
+CLASS* parse(PARSER* p);
+void freeparser(PARSER* p);
 #endif