void free_algo(struct algo *algo) { free_instructions(algo->instructions); free_decls(algo->declarations); free(algo->ident); if (algo->return_type) free(algo->return_type); free(algo); }
void free_prog(struct prog *prog) { free_var_decl(prog->entry_point->var_decl); free_const_decl(prog->entry_point->const_decls); free_type_decls(prog->entry_point->type_decls); free_instructions(prog->entry_point->instructions); free(prog->entry_point); for (unsigned i = 0; i < prog->algos.size; ++i) free_algo(prog->algos.data[i]); list_free(prog->algos); free(prog); }
/* Run yyparse and return a pointer to the first instruction if no errors occur, otherwise return NULL */ Instruction* parse() { opcode_init(); yyparse(); if (error_found) { free_instructions(first_instruction); return NULL; } else { return first_instruction; } }
void free_instruction(struct instruction *i) { switch (i->kind) { case assignment: free_expression(i->instr.assignment->e1); free_expression(i->instr.assignment->e2); free(i->instr.assignment); break; case switchcase: free_caseblocklist(i->instr.switchcase->caseblocklist); free_instructions(i->instr.switchcase->otherwiseblock); free_expression(i->instr.switchcase->cond); free(i->instr.switchcase); break; case dowhile: free_expression(i->instr.dowhile->cond); free_instructions(i->instr.dowhile->instructions); free(i->instr.dowhile); break; case whiledo: free_expression(i->instr.whiledo->cond); free_instructions(i->instr.whiledo->instructions); free(i->instr.whiledo); break; case forloop: free_expression(i->instr.forloop->assignment->e1); free_expression(i->instr.forloop->assignment->e2); free(i->instr.forloop->assignment); free_instructions(i->instr.forloop->instructions); free_expression(i->instr.forloop->upto); free(i->instr.forloop); break; case funcall: free_args(i->instr.funcall->args); free(i->instr.funcall->fun_ident); free(i->instr.funcall); break; case ifthenelse: free_expression(i->instr.ifthenelse->cond); free_instructions(i->instr.ifthenelse->instructions); free_instructions(i->instr.ifthenelse->elseblock); free(i->instr.ifthenelse); break; case returnstmt: free_expression(i->instr.returnstmt->expr); free(i->instr.returnstmt); break; } free(i); }
void make_memory (int text_size, int data_size, int data_limit, int stack_size, int stack_limit, int k_text_size, int k_data_size, int k_data_limit) { if (data_size <= 65536) data_size = 65536; data_size = ROUND_UP(data_size, BYTES_PER_WORD); /* Keep word aligned */ if (text_seg == NULL) text_seg = (instruction **) xmalloc (BYTES_TO_INST(text_size)); else { free_instructions (text_seg, (text_top - TEXT_BOT) / BYTES_PER_WORD); text_seg = (instruction **) realloc (text_seg, BYTES_TO_INST(text_size)); } memclr (text_seg, BYTES_TO_INST(text_size)); text_top = TEXT_BOT + text_size; data_size = ROUND_UP(data_size, BYTES_PER_WORD); /* Keep word aligned */ if (data_seg == NULL) data_seg = (mem_word *) xmalloc (data_size); else data_seg = (mem_word *) realloc (data_seg, data_size); memclr (data_seg, data_size); data_seg_b = (BYTE_TYPE *) data_seg; data_seg_h = (short *) data_seg; data_top = DATA_BOT + data_size; data_size_limit = data_limit; stack_size = ROUND_UP(stack_size, BYTES_PER_WORD); /* Keep word aligned */ if (stack_seg == NULL) stack_seg = (mem_word *) xmalloc (stack_size); else stack_seg = (mem_word *) realloc (stack_seg, stack_size); memclr (stack_seg, stack_size); stack_seg_b = (BYTE_TYPE *) stack_seg; stack_seg_h = (short *) stack_seg; stack_bot = STACK_TOP - stack_size; stack_size_limit = stack_limit; if (k_text_seg == NULL) k_text_seg = (instruction **) xmalloc (BYTES_TO_INST(k_text_size)); else { free_instructions (k_text_seg, (k_text_top - K_TEXT_BOT) / BYTES_PER_WORD); k_text_seg = (instruction **) realloc(k_text_seg, BYTES_TO_INST(k_text_size)); } memclr (k_text_seg, BYTES_TO_INST(k_text_size)); k_text_top = K_TEXT_BOT + k_text_size; k_data_size = ROUND_UP(k_data_size, BYTES_PER_WORD); /* Keep word aligned */ if (k_data_seg == NULL) k_data_seg = (mem_word *) xmalloc (k_data_size); else k_data_seg = (mem_word *) realloc (k_data_seg, k_data_size); memclr (k_data_seg, k_data_size); k_data_seg_b = (BYTE_TYPE *) k_data_seg; k_data_seg_h = (short *) k_data_seg; k_data_top = K_DATA_BOT + k_data_size; k_data_size_limit = k_data_limit; text_modified = 1; data_modified = 1; }
void free_caseblock(struct caseblock *caseblock) { free_expressions(caseblock->exprlist); free_instructions(caseblock->instructions); free(caseblock); }