static void dumpStatements( void ) {
/**********************************/
/* loop through statements and create new sru file by dumping them out */
FILE *fout;
statement *curr;
/* open file */
fout = WigOpenFile( GetOutputFile(), "wt" );
if( !fout ) {
Error( FILE_OPEN_ERR, GetOutputFile() );
}
/* loop and udmp */
curr = SRU.head_stmt;
while( curr ) {
assert( curr->stmt );
fprintf( fout, "%s", curr->stmt );
SRU.head_stmt = curr->next;
if( curr->keep ) {
curr = curr->next;
} else {
/* free if not required for back end */
freeStatement( curr );
curr = SRU.head_stmt;
}
}
WigCloseFile( fout );
}
ScopLib::~ScopLib() {
if (!scoplib)
return;
// Free array names.
for (int i = 0; i < scoplib->nb_arrays; ++i)
free(scoplib->arrays[i]);
free(scoplib->arrays);
scoplib->arrays = NULL;
scoplib->nb_arrays = 0;
// Free parameters
for (int i = 0; i < scoplib->nb_parameters; ++i)
free(scoplib->parameters[i]);
free(scoplib->parameters);
scoplib->parameters = NULL;
scoplib->nb_parameters = 0;
scoplib_statement_p stmt = scoplib->statement;
// Free Statements
while (stmt) {
scoplib_statement_p TempStmt = stmt->next;
stmt->next = NULL;
freeStatement(stmt);
stmt = TempStmt;
}
scoplib->statement = NULL;
scoplib_scop_free(scoplib);
}
void FreeSru( void ) {
/*********************/
statement *curr;
if( SRU.name ) {
MemFree( SRU.name );
}
if( SRU.con_name ) {
MemFree( SRU.con_name );
}
if( SRU.name ) {
MemFree( SRU.des_name );
}
while( SRU.head_stmt ) {
curr = SRU.head_stmt;
SRU.head_stmt = curr->next;
freeStatement( curr );
}
DestroyHashTable( SRU.type_prots );
DestroyHashTable( SRU.typ_tab );
memset( &SRU, 0, sizeof( sru_file ) ); /* clear all records */
}
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
}
static statement *replaceStatement( statement *locale, char *stmt ) {
/*******************************************************************/
statement *link;
assert( stmt );
assert( locale );
if( !locale->next ) {
locale->next = mkStatement( stmt );
SRU.tail_stmt = locale->next;
} else {
link = locale->next;
locale->next = mkStatement( stmt );
locale->next->next = link->next;
if( link == SRU.tail_stmt ) {
SRU.tail_stmt = locale->next;
}
if( !link->keep ) {
freeStatement( link );
}
}
return( locale->next );
}
/**
* 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
}
