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 }