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;
}
