void freeGrammarList(GrammarList g) {
#ifdef MEMTRACE
printf("Freeing grammar list\n");
#endif
if(g == NULL) {
fprintf(stderr, "Null child GrammarList\n");
return;
}
while(g->head) {
void *d = popFront(g);
switch(g->type) {
case argument:
freeExpression((Expression)d);
break;
case statement:
freeStatement((Statement)d);
break;
case parameterList:
freeParameter((Parameter)d);
break;
case expressionList:
freeExpression((Expression)d);
break;
}
}
freeTypeCheckType(g->tt);
if(g->code)
free(g->code);
if(g->precode)
free(g->precode);
if(g->postcode)
free(g->postcode);
free(g);
#ifdef MEMTRACE
printf("Grammar list freed\n");
#endif
}
void
freeOperand(operandType *operand)
{
nullFree(operand);
switch (operand->kindOfOperand) {
case EXPRESSION_OPND:
case IMMEDIATE_OPND:
case INDIRECT_OPND:
case POST_INDEXED_Y_OPND:
case PRE_INDEXED_X_OPND:
case X_INDEXED_OPND:
case Y_INDEXED_OPND:
freeExpression(operand->theOperand.expressionUnion);
break;
case A_REGISTER_OPND:
case X_REGISTER_OPND:
case Y_REGISTER_OPND:
break;
case X_SELECTED_OPND:
case Y_SELECTED_OPND:
case PRE_SELECTED_X_OPND:
freeSelectionList(operand->theOperand.xSelectedUnion);
break;
case STRING_OPND:
freeString(operand->theOperand.stringUnion);
break;
case BLOCK_OPND:
freeBlock(operand->theOperand.blockUnion);
break;
default:
botch("bad operand kind in freeOperand %d\n",
operand->kindOfOperand);
break;
}
freeOperand(operand->nextOperand);
free(operand);
}
/**
* Recursively free the Statement and its children in postorder.
*/
void freeStatement(Statement s) {
#ifdef MEMTRACE
printf("Freeing statement\n");
#endif
if(s == NULL) {
fprintf(stderr, "Null child Statement\n");
return;
}
switch(s->type) {
case expression:
freeExpression(s->sub1.e);
break;
case iteration:
switch(s->deriv.iteration) {
case forIter:
freeExpression(s->sub1.forloop.e1);
freeExpression(s->sub1.forloop.e2);
freeExpression(s->sub1.forloop.e3);
freeCompoundStatement(s->sub2.cs);
break;
case whileIter:
freeExpression(s->sub1.e);
freeCompoundStatement(s->sub2.cs);
break;
}
break;
case decl:
freeIdentifier(s->sub2.i);
break;
case selection:
switch(s->deriv.selection) {
case ifStatement:
freeCompoundStatement(s->sub2.cs);
freeExpression(s->sub1.e);
break;
case ifelseStatement:
freeExpression(s->sub1.e);
freeCompoundStatement(s->sub2.cs);
freeCompoundStatement(s->sub3.cs);
break;
}
break;
case dictlist:
freeIdentifier(s->sub1.i);
freeExpression(s->sub2.e);
break;
case dict:
switch(s->deriv.dict) {
case definitions:
freeIdentifier(s->sub1.i);
freeCompoundStatement(s->sub2.cs);
break;
case none:
freeIdentifier(s->sub1.i);
break;
}
break;
case node:
switch(s->deriv.node) {
case nodeCreate:
freeIdentifier(s->sub1.i);
break;
case nodeAssignment:
freeIdentifier(s->sub1.i);
freeExpression(s->sub2.e);
break;
case nodeDictAssignment:
freeIdentifier(s->sub1.i);
freeCompoundStatement(s->sub2.cs);
break;
}
break;
case edge:
switch(s->deriv.edge) {
case none:
freeIdentifier(s->sub1.i);
break;
default:
freeIdentifier(s->sub1.i);
freeExpression(s->sub2.e);
freeExpression(s->sub3.e);
break;
}
break;
case none:
freeStatement(s->sub1.s);
break;
default:
break;
}
freeTypeCheckType(s->tt);
if(s->code)
free(s->code);
free(s);
#ifdef MEMTRACE
printf("Statement freed\n");
#endif
}
/**
* Recursively free an expression and its children in postorder
*/
void freeExpression(Expression e) {
#ifdef MEMTRACE
printf("Freeing expression\n");
#endif
if(e == NULL) {
fprintf(stderr, "Null child Expression\n");
return;
}
switch (e->type) {
case postfix:
switch (e->deriv.postfix) {
case identifier:
freeIdentifier(e->sub2.i);
freeExpression(e->sub1.e);
break;
case postdecr:
freeExpression(e->sub1.e);
break;
case postincr:
freeExpression(e->sub1.e);
break;
case arg:
freeExpression(e->sub1.e);
freeGrammarList(e->sub2.l);
break;
case argEmpty:
freeExpression(e->sub1.e);
break;
case bracket:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
case 0:
freeExpression(e->sub1.e);
break;
}
break;
case unary:
freeExpression(e->sub1.e);
break;
case cast:
switch(e->deriv.cast){
case typed:
freeExpression(e->sub2.e);
break;
case 0:
freeExpression(e->sub1.e);
break;
}
break;
case mult:
switch(e->deriv.mult){
case 0:
freeExpression(e->sub1.e);
break;
default:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
}
break;
case add:
switch(e->deriv.add){
case 0:
freeExpression(e->sub1.e);
break;
default:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
}
break;
case relat:
switch(e->deriv.relat){
case 0:
freeExpression(e->sub1.e);
break;
default:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
}
break;
case eq:
switch(e->deriv.eq){
case 0:
freeExpression(e->sub1.e);
break;
default:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
}
break;
case cond:
switch(e->deriv.eq){
case 0:
freeExpression(e->sub1.e);
break;
default:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
}
break;
case assignment:
switch(e->deriv.assign){
case init:
freeIdentifier(e->sub2.i);
freeExpression(e->sub3.e);
break;
case 0:
freeExpression(e->sub1.e);
break;
default:
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
break;
}
break;
case primary:
switch(e->deriv.primary){
case primary_string:
free(e->sub1.s);
break;
case primary_identifier:
freeIdentifier(e->sub1.i);
break;
case parentheses:
freeExpression(e->sub1.e);
break;
default: //suppresses warnings about primary_none
break;
}
break;
case function:
freeIdentifier(e->sub1.i);
freeGrammarList(e->sub2.l);
break;
case none:
if(!e->deriv.none)
freeExpression(e->sub1.e);
else if(e->deriv.none == comma) {
freeExpression(e->sub1.e);
freeExpression(e->sub2.e);
}
break;
default:
break;
}
freeTypeCheckType(e->tt);
if(e->code)
free(e->code);
if(e->precode)
free(e->precode);
if(e->postcode)
free(e->postcode);
free(e);
#ifdef MEMTRACE
printf("Expression freed\n");
#endif
}