static void free_address_space(UM_machine machine) { UM_address_space address_space = machine->address_space; /* free the mapped segments sequence */ int length = Seq_length(address_space->mapped_segments); for(int i=0; i<length; i++){ UM_segment segment = Seq_remlo(address_space->mapped_segments); /* if segment with ID == i is mapped, free it */ if(segment != NULL){ free_segment_memory(&segment); } } Seq_free(&address_space->mapped_segments); /* free the reusable IDs sequence */ for(int i=0; i<Seq_length(address_space->reusable_IDs); i++){ UM_segment_ID *seg_ID = Seq_get(address_space->reusable_IDs, i); free(seg_ID); } Seq_free(&(address_space->reusable_IDs)); free(address_space); }
/* stabend - emits the symbol table */ static void stabend(Coordinate *cp, Symbol symroot, Coordinate *cpp[], Symbol sp[], Symbol *ignore) { Symbol addresses; int naddresses, nmodule; { /* annotate top-level symbols */ Symbol p; for (p = symroot; p != NULL; p = up(p->up)) symboluid(p); pickle->globals = symboluid(symroot); } { /* emit addresses of top-level and static symbols */ int i, lc = 0, count = Seq_length(statics); addresses = genident(STATIC, array(voidptype, 1, 0), GLOBAL); comment("addresses:\n"); defglobal(addresses, LIT); for (i = 0; i < count; i++) { Symbol p = Seq_get(statics, i); lc = emit_value(lc, voidptype, p); } lc = pad(maxalign, lc); naddresses = lc; Seq_free(&statics); } { /* emit bp count as an alias for the module */ Symbol spoints = mksymbol(AUTO, stringf("_spoints_V%x_%d", uname, Seq_length(pickle->spoints)), array(unsignedtype, 0, 0)); spoints->generated = 1; defglobal(spoints, LIT); } { /* emit module */ int lc; comment("module:\n"); defglobal(module, LIT); lc = emit_value( 0, unsignedtype, (unsigned long)uname); lc = emit_value(lc, voidptype, addresses); lc = pad(maxalign, lc); nmodule = lc; } Seq_free(&locals); #define printit(x) fprintf(stderr, "%7d " #x "\n", n##x); total += n##x { int total = 0; printit(addresses); printit(module); fprintf(stderr, "%7d bytes total\n", total); } #undef printit { /* complete and write symbol-table pickle */ FILE *f = fopen(stringf("%d.pickle", uname), "wb"); sym_write_module(pickle, f); fclose(f); } }
/* * Input: Mem_T structure * Output: void * Purpose: Frees all memory. Frees each segment, the sequence of segments, * the sequence of reusable indices and the pointer to the memory * structure */ void MemT_free(Mem_T memory){ int length = Seq_length(memory->segment_seq); for(int i = 0; i < length; i++){ Seq_T segment = Seq_get(memory->segment_seq, i); if(segment != NULL) Seq_free(&segment); } Seq_free(&(memory->segment_seq)); Seq_free(&(memory->reusable_indices)); free(memory); }
/* Frees all segmented memory created by the program, including the segment * where the program is stored. */ void Segment_free(T * seg_memory) { int len = Seq_length((*seg_memory)->segments); int i; for (i = 0; i < len; i++) { free(Seq_get((*seg_memory)->segments, i)); } Seq_free(&((*seg_memory)->segments)); Seq_free(&((*seg_memory)->unmapped_ids)); free (*seg_memory); }
void unblack (Bit2_T bitmap, int cur_x, int cur_y) { int w_pixels = Bit2_width (bitmap); int h_pixels = Bit2_height (bitmap); Seq_T point_queue = Seq_new(w_pixels*h_pixels); assert(point_queue); assert(0 <= cur_x && cur_x < w_pixels); assert(0 <= cur_y && cur_y < h_pixels); if (Bit2_get(bitmap, cur_x, cur_y) != 1) { // if pixel is white assert(point_queue); Seq_free(&point_queue); return; } else { Seq_addhi(point_queue, (void*)makePoint(cur_x,cur_y)); while (Seq_length(point_queue) > 0) { PointPair temp = (PointPair)Seq_remlo(point_queue); assert(temp); int i = temp->i; int j = temp->j; freePoint(temp); if (Bit2_get(bitmap, i, j) == 1) { // if current is black pixel Bit2_put(bitmap, i, j, 0); // set current to white assert(0 <= i && i < w_pixels); assert(0 <= j && j < h_pixels); if (j != 0 && j != h_pixels-1) { // if not a top/bottom pixel if (i+1 < w_pixels && Bit2_get(bitmap, i+1, j) == 1) { // if Seq_addhi(point_queue, (void*)makePoint(i+1,j)); } if (i > 0 && Bit2_get(bitmap, i-1, j) == 1) { Seq_addhi(point_queue, (void*)makePoint(i-1,j)); } } if (i != 0 && i != w_pixels-1) { if (j+1 < h_pixels && Bit2_get(bitmap, i, j+1) == 1) { Seq_addhi(point_queue, (void*)makePoint(i,j+1)); } if (j > 0 && Bit2_get(bitmap, i, j-1) == 1) { Seq_addhi(point_queue, (void*)makePoint(i,j-1)); } } } } assert(point_queue); Seq_free(&point_queue); return; } }
/* * Frees all the memory associated with the Segment Manager * Parameter: sm - The Segment Manager Struct */ void segment_Free(Segment_Manager sm) { Segment nextsegment; while (Seq_length(sm->Segment_Table) != 0) { nextsegment = (UArray_T)Seq_remhi(sm->Segment_Table); if (nextsegment != NULL) UArray_free(&nextsegment); }; Seq_free(&(sm->Segment_Table)); Seq_free(&(sm->ID_Stack)); free(sm); return; }
/* * halt: Computation stops and deletes all memory that is allocated. */ void halt(Seq_T segMem, Seq_T delMem, uint32_t *arr) { while (Seq_length(segMem) != 0) { struct segment *s = Seq_remlo(segMem); if (s != NULL) { free(s->mem); free(s); } } Seq_free(&segMem); Seq_free(&delMem); free(arr); exit(EXIT_SUCCESS); }
/* * Initializes the program counter and returns the number of instructions. */ void mapProgram(FILE* program) { Seq_T words = Seq_new(PROGRAM_HINT); int c = getc(program); while(c != EOF) { UM_Word temp = 0; temp = Bitpack_newu(temp, 8, 24, c); for(int bit = 16; bit >=0; bit -=8){ int b = getc(program); temp = Bitpack_newu(temp, 8, bit, b); } UM_Word* instr; NEW(instr); *instr = temp; Seq_addhi(words, instr); c = getc(program); } mapSegment(memorySegments, 0); mapInstructions(Seq_length(words)); int length = instructionLength(); for(int locToLoad = 0; locToLoad < length; locToLoad++){ UM_Word* value = (UM_Word*)Seq_get(words, locToLoad); loadInstruction(locToLoad, *value); FREE(value); } Seq_free(&words); }
int main() { Seq_T values = Seq_new(10); run(values); Seq_free(&values); return EXIT_SUCCESS; }
void Umsections_free(T *asmp) { Table_map((*asmp)->sections,applyFree,NULL); Table_free(&((*asmp)->sections)); Seq_free(&((*asmp)->sectionOrder)); // Seq_free(((*asmp)->currentSection)); free(*asmp); }
/* A Table_map apply function used to free the seqs stored in the table */ void apply_free(const void *key, void **value, void *cl) { (void)key; (void)cl; Seq_T tmp = *value; Seq_free(&tmp); }
/* Frees a given Umsections_T */ void Umsections_free(Umsections_T *asmp) { Table_map((*asmp)->table, apply_free, NULL); Table_free(&((*asmp)->table)); Seq_free(&((*asmp)->order)); free(*asmp); }
__declspec(dllexport) void curl_shim_free_strings(void* p) { int i, count; Seq_T seq = (Seq_T)p; count = Seq_length(seq); for (i = 0; i < count; i++) free(Seq_get(seq, i)); Seq_free(&seq); }
/* free the mem */ void free_mem(Mem* myMem) { assert(myMem != NULL); for (int i = 0; i < Seq_length((*myMem)->segs); i++) { Seg_free(Seq_get((*myMem)->segs, i)); } Seq_free(&((*myMem)->segs)); Stack_free(&((*myMem)->unmapped)); free(*myMem); }
void check_map_large(){ //These variable created for compiling sake Seq_T SEG_MEMORY = Seq_new(100); Seq_T UNMAP_SEQ = Seq_new(10); Umsegment_Id one = map_segment(6); Umsegment_Id two = map_segment(6); Umsegment_Id three = map_segment(8000); Umsegment_Id four = map_segment(6); int size = UArray_length(Seq_get(SEG_MEMORY, three)); if (size != 8000) fprintf(stderr, "Big segment is incorrect size %d.\n", size); unmap_segment(one); unmap_segment(two); unmap_segment(three); unmap_segment(four); Seq_free(&SEG_MEMORY); Seq_free(&UNMAP_SEQ); }
void Segmem_free(T segmem) { int i; for(i = 0; i < segmem->length; i++) { int *array = (int *)Seq_get(segmem->memory, i); //printf("%p\n", (void *)(array)); free(array); } Seq_free(&(segmem->memory)); }
/* frees all of the segments and their contents */ void free_all(Segment outer) { assert(outer); int num_segs = Seq_length(outer); for (int i = 0; i < num_segs; i++) { UArray_T inner = Seq_get(outer, i); UArray_free(&inner); } Seq_free(&outer); }
void check_map_capcity(){ //These variable created for compiling sake Seq_T SEG_MEMORY = Seq_new(100); Seq_T UNMAP_SEQ = Seq_new(10); for (int i = 0; i < 2000; i++){ int size = rand() % 20; Umsegment_Id id = map_segment(size); (void) id; if (Seq_get(SEG_MEMORY, i) == NULL) fprintf(stderr, "Segment %d not mapped.\n", size); i++; } for (int j = 1999; j >= 0; j--){ unmap_segment((Umsegment_Id) j); if (Seq_get(SEG_MEMORY, j) != NULL) fprintf(stderr, "Segment %d not unmapped.\n", j); } Seq_free(&SEG_MEMORY); Seq_free(&UNMAP_SEQ); }
void check_unmap(){ //These variable created for compiling sake Seq_T SEG_MEMORY = Seq_new(100); Seq_T UNMAP_SEQ = Seq_new(10); Umsegment_Id one = map_segment(10); Umsegment_Id two = map_segment(15); Umsegment_Id three = map_segment(20); Umsegment_Id four = map_segment(25); unmap_segment(two); if ((Umsegment_Id)(uintptr_t)Seq_remhi(UNMAP_SEQ) != 15) fprintf(stderr, "Unmapped id was not found in sequence"); Umsegment_Id five = map_segment(5); if(five != two) fprintf(stderr, "Unmapped id was not used"); unmap_segment(one); unmap_segment(five); unmap_segment(three); unmap_segment(four); Seq_free(&SEG_MEMORY); Seq_free(&UNMAP_SEQ); }
/* * Input: Mem_T structure, unsigned integer * Ouput: void * Purpose: Copies the segment located at segIndex and stores it in segment 0 * The segment previously at index 0 is freed. */ void load_program(Mem_T memory, unsigned segIndex) { /*Segment that will become new program*/ Seq_T program_to_load_temp = Seq_get(memory->segment_seq, segIndex); int length = Seq_length(program_to_load_temp); /*New sequence that will be put in segment 0*/ Seq_T program_to_load = Seq_new(length); /*Copies program_to_load_temp to program_to_load*/ for(int i = 0; i < length; i++) { Seq_addhi(program_to_load, Seq_get(program_to_load_temp, i)); } Seq_T old_program = Seq_put(memory->segment_seq, 0, program_to_load); Seq_free(&old_program); }
int run( FILE* fin ) { char word[64]; size_t wsize = sizeof( word ); while (fgets( word, wsize, fin )) { Seq_T solutions = Seq_new( 5 ); if (wstable_hasWord( word, solutions )) { process_solutions( solutions ); } Seq_free( &solutions ); } return 0; }
void print(Table_T files) { int i; void **array = Table_toArray(files, NULL); qsort(array, Table_length(files), 2*sizeof (*array), compare); for (i = 0; array[i]; i += 2) { Seq_T seq = array[i+1]; char *filename = array[i]; if (*filename) Fmt_print("\t%S:", filename, 1, 0); while (Seq_length(seq) > 0) Fmt_print(" %S", Seq_remhi(seq), 1, 0); Fmt_print("\n"); FREE(filename); Seq_free(&seq); } FREE(array); Table_free(&files); }
void applyFree(const void *key,void **value, void *cl){ (void) key; (void) cl; Seq_free((((Seq_T*)value))); }
/* * Input: Mem_T structure, unsigned integer * Output: void * Purpose: Unmaps a segment from memory at the given segment index and frees * all memory associated with it. */ void unmap_segment(Mem_T memory, unsigned segIndex) { Seq_T unmapped_segment = Seq_put(memory->segment_seq, segIndex, NULL); Seq_free(&unmapped_segment); Seq_addhi(memory->reusable_indices, (void *)(intptr_t)segIndex); }
static void *uid2type(int uid) { assert(uid >= 0 && uid < nuids); if (itemmap[uid] == NULL) { Type ty; rcc_type_ty type = (void *)items[uid]; assert(items[uid]); assert(items[uid]->uid == uid); assert(items[uid]->kind == rcc_Type_enum); type = items[uid]->v.rcc_Type.type; assert(type); switch (type->kind) { case rcc_INT_enum: ty = btot(INT, type->size); assert(ty->align == type->align); break; case rcc_UNSIGNED_enum: ty = btot(UNSIGNED, type->size); assert(ty->align == type->align); break; case rcc_FLOAT_enum: ty = btot(FLOAT, type->size); assert(ty->align == type->align); break; case rcc_VOID_enum: ty = voidtype; break; case rcc_POINTER_enum: ty = ptr(uid2type(type->v.rcc_POINTER.type)); break; case rcc_ARRAY_enum: ty = uid2type(type->v.rcc_ARRAY.type); assert(ty->size > 0); ty = array(ty, type->size/ty->size, 0); break; case rcc_CONST_enum: ty = qual(CONST, uid2type(type->v.rcc_CONST.type)); break; case rcc_VOLATILE_enum: ty = qual(VOLATILE, uid2type(type->v.rcc_VOLATILE.type)); break; case rcc_ENUM_enum: { int i, n = Seq_length(type->v.rcc_ENUM.ids); ty = newstruct(ENUM, string(type->v.rcc_ENUM.tag)); ty->type = inttype; ty->size = ty->type->size; ty->align = ty->type->align; ty->u.sym->u.idlist = newarray(n + 1, sizeof *ty->u.sym->u.idlist, PERM); for (i = 0; i < n; i++) { rcc_enum__ty e = Seq_remlo(type->v.rcc_ENUM.ids); Symbol p = install(e->id, &identifiers, GLOBAL, PERM); p->type = ty; p->sclass = ENUM; p->u.value = e->value; ty->u.sym->u.idlist[i] = p; free(e); } ty->u.sym->u.idlist[i] = NULL; Seq_free(&type->v.rcc_ENUM.ids); break; } case rcc_STRUCT_enum: case rcc_UNION_enum: { int i, n; Field *tail; list_ty fields; if (type->kind == rcc_STRUCT_enum) { ty = newstruct(STRUCT, string(type->v.rcc_STRUCT.tag)); fields = type->v.rcc_STRUCT.fields; } else { ty = newstruct(UNION, string(type->v.rcc_UNION.tag)); fields = type->v.rcc_UNION.fields; } itemmap[uid] = ty; /* recursive types */ ty->size = type->size; ty->align = type->align; tail = &ty->u.sym->u.s.flist; n = Seq_length(fields); for (i = 0; i < n; i++) { rcc_field_ty field = Seq_remlo(fields); NEW0(*tail, PERM); (*tail)->name = (char *)field->id; (*tail)->type = uid2type(field->type); (*tail)->offset = field->offset; (*tail)->bitsize = field->bitsize; (*tail)->lsb = field->lsb; if (isconst((*tail)->type)) ty->u.sym->u.s.cfields = 1; if (isvolatile((*tail)->type)) ty->u.sym->u.s.vfields = 1; tail = &(*tail)->link; free(field); } Seq_free(&fields); break; } case rcc_FUNCTION_enum: { int n = Seq_length(type->v.rcc_FUNCTION.formals); if (n > 0) { int i; Type *proto = newarray(n + 1, sizeof *proto, PERM); for (i = 0; i < n; i++) { int *formal = Seq_remlo(type->v.rcc_FUNCTION.formals); proto[i] = uid2type(*formal); free(formal); } proto[i] = NULL; ty = func(uid2type(type->v.rcc_FUNCTION.type), proto, 0); } else ty = func(uid2type(type->v.rcc_FUNCTION.type), NULL, 1); Seq_free(&type->v.rcc_FUNCTION.formals); break; } default: assert(0); } if (itemmap[uid] == NULL) { itemmap[uid] = ty; free(type); free(items[uid]); items[uid] = NULL; } else assert(itemmap[uid] == ty); } return itemmap[uid]; }
int main(int argc, char *argv[]) { int c; sp = Seq_new(0); Fmt_register('D', MP_fmt); Fmt_register('U', MP_fmtu); while ((c = getchar()) != EOF) { MP_T x = NULL, y = NULL, z = NULL; TRY switch (c) { default: if (isprint(c)) Fmt_fprint(stderr, "?'%c'", c); else Fmt_fprint(stderr, "?'\\%03o'", c); Fmt_fprint(stderr, " is unimplemented\n"); break; case ' ': case '\t': case '\n': case '\f': case '\r': break; case 'c': while (Seq_length(sp) > 0) { MP_T x = Seq_remhi(sp); FREE(x); } break; case 'q': while (Seq_length(sp) > 0) { MP_T x = Seq_remhi(sp); FREE(x); } Seq_free(&sp); return EXIT_SUCCESS; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { char buf[512]; z = MP_new(0); { int i = 0; for ( ; strchr(&"zyxwvutsrqponmlkjihgfedcba9876543210"[36-ibase], tolower(c)); c = getchar(), i++) if (i < (int)sizeof (buf) - 1) buf[i] = c; if (i > (int)sizeof (buf) - 1) { i = (int)sizeof (buf) - 1; Fmt_fprint(stderr, "?integer constant exceeds %d digits\n", i); } buf[i] = '\0'; if (c != EOF) ungetc(c, stdin); } MP_fromstr(z, buf, ibase, NULL); break; } case '+': y = pop(); x = pop(); z = MP_new(0); (*f->add)(z, x, y); break; case '-': y = pop(); x = pop(); z = MP_new(0); (*f->sub)(z, x, y); break; case '*': y = pop(); x = pop(); z = MP_new(0); (*f->mul)(z, x, y); break; case '/': y = pop(); x = pop(); z = MP_new(0); (*f->div)(z, x, y); break; case '%': y = pop(); x = pop(); z = MP_new(0); (*f->mod)(z, x, y); break; case '&': y = pop(); x = pop(); z = MP_new(0); MP_and(z, x, y); break; case '|': y = pop(); x = pop(); z = MP_new(0); MP_or (z, x, y); break; case '^': y = pop(); x = pop(); z = MP_new(0); MP_xor(z, x, y); break; case '!': z = pop(); MP_not(z, z); break; case '~': z = pop(); MP_neg(z, z); break; case 'i': case 'o': { long n; x = pop(); n = MP_toint(x); if (n < 2 || n > 36) Fmt_fprint(stderr, "?%d is an illegal base\n",n); else if (c == 'i') ibase = n; else obase = n; if (obase == 2 || obase == 8 || obase == 16) f = &u; else f = &s; break; } case 'p': Fmt_print(f->fmt, z = pop(), obase); break; case 'f': { int n = Seq_length(sp); while (--n > 0) Fmt_print(f->fmt, Seq_get(sp, n), obase); break; } case '<': { long s; y = pop(); z = pop(); s = MP_toint(y); if (s < 0 || s > INT_MAX) { Fmt_fprint(stderr, "?%d is an illegal shift amount\n", s); break; }; MP_lshift(z, z, s); break; } case '>': { long s; y = pop(); z = pop(); s = MP_toint(y); if (s < 0 || s > INT_MAX) { Fmt_fprint(stderr, "?%d is an illegal shift amount\n", s); break; }; MP_rshift(z, z, s); break; } case 'k': { long n; x = pop(); n = MP_toint(x); if (n < 2 || n > INT_MAX) Fmt_fprint(stderr, "?%d is an illegal precision\n", n); else if (Seq_length(sp) > 0) Fmt_fprint(stderr, "?nonempty stack\n"); else MP_set(n); break; } case 'd': { MP_T x = pop(); z = MP_new(0); Seq_addhi(sp, x); MP_addui(z, x, 0); break; } } EXCEPT(MP_Overflow) Fmt_fprint(stderr, "?overflow\n"); EXCEPT(MP_Dividebyzero) Fmt_fprint(stderr, "?divide by 0\n"); END_TRY; if (z) Seq_addhi(sp, z); FREE(x); FREE(y); } while (Seq_length(sp) > 0) { MP_T x = Seq_remhi(sp); FREE(x); } Seq_free(&sp); return EXIT_SUCCESS; }