mirror of
https://github.com/justinethier/cyclone.git
synced 2025-05-23 20:15:05 +02:00
Remove dead code
This commit is contained in:
Justin Ethier
parent
a5fefda485
commit
ac9b197803
1 changed files with 0 additions and 399 deletions
399
runtime.c
399
runtime.c
|
|
@ -2086,405 +2086,6 @@ void Cyc_apply_from_buf(void *data, int argc, object prim, object *buf) {
|
|||
apply(data, cont, prim, (object)&args[0]);
|
||||
}
|
||||
|
||||
///**
|
||||
// * Copy an object to the GC heap
|
||||
// */
|
||||
//char *transport(x, gcgen) char *x; int gcgen;
|
||||
//{
|
||||
// if (nullp(x)) return x;
|
||||
// if (obj_is_char(x)) return x;
|
||||
//#if DEBUG_GC
|
||||
// printf("entered transport ");
|
||||
// printf("transport %ld\n", type_of(x));
|
||||
//#endif
|
||||
// switch (type_of(x))
|
||||
// {case cons_tag:
|
||||
// {register list nx = (list) allocp;
|
||||
// type_of(nx) = cons_tag; car(nx) = car(x); cdr(nx) = cdr(x);
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// allocp = ((char *) nx)+sizeof(cons_type);
|
||||
// return (char *) nx;}
|
||||
// case macro_tag:
|
||||
// {register macro nx = (macro) allocp;
|
||||
// type_of(nx) = macro_tag; nx->fn = ((macro) x)->fn;
|
||||
// nx->num_args = ((macro) x)->num_args;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// allocp = ((char *) nx)+sizeof(macro_type);
|
||||
// return (char *) nx;}
|
||||
// case closure0_tag:
|
||||
// {register closure0 nx = (closure0) allocp;
|
||||
// type_of(nx) = closure0_tag; nx->fn = ((closure0) x)->fn;
|
||||
// nx->num_args = ((closure0) x)->num_args;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// allocp = ((char *) nx)+sizeof(closure0_type);
|
||||
// return (char *) nx;}
|
||||
// case closure1_tag:
|
||||
// {register closure1 nx = (closure1) allocp;
|
||||
// type_of(nx) = closure1_tag; nx->fn = ((closure1) x)->fn;
|
||||
// nx->num_args = ((closure1) x)->num_args;
|
||||
// nx->elt1 = ((closure1) x)->elt1;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(closure1_type);
|
||||
// return (char *) nx;}
|
||||
// case closure2_tag:
|
||||
// {register closure2 nx = (closure2) allocp;
|
||||
// type_of(nx) = closure2_tag; nx->fn = ((closure2) x)->fn;
|
||||
// nx->num_args = ((closure2) x)->num_args;
|
||||
// nx->elt1 = ((closure2) x)->elt1;
|
||||
// nx->elt2 = ((closure2) x)->elt2;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(closure2_type);
|
||||
// return (char *) nx;}
|
||||
// case closure3_tag:
|
||||
// {register closure3 nx = (closure3) allocp;
|
||||
// type_of(nx) = closure3_tag; nx->fn = ((closure3) x)->fn;
|
||||
// nx->num_args = ((closure3) x)->num_args;
|
||||
// nx->elt1 = ((closure3) x)->elt1;
|
||||
// nx->elt2 = ((closure3) x)->elt2;
|
||||
// nx->elt3 = ((closure3) x)->elt3;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(closure3_type);
|
||||
// return (char *) nx;}
|
||||
// case closure4_tag:
|
||||
// {register closure4 nx = (closure4) allocp;
|
||||
// type_of(nx) = closure4_tag; nx->fn = ((closure4) x)->fn;
|
||||
// nx->num_args = ((closure4) x)->num_args;
|
||||
// nx->elt1 = ((closure4) x)->elt1;
|
||||
// nx->elt2 = ((closure4) x)->elt2;
|
||||
// nx->elt3 = ((closure4) x)->elt3;
|
||||
// nx->elt4 = ((closure4) x)->elt4;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(closure4_type);
|
||||
// return (char *) nx;}
|
||||
// case closureN_tag:
|
||||
// {register closureN nx = (closureN) allocp;
|
||||
// int i;
|
||||
// type_of(nx) = closureN_tag; nx->fn = ((closureN) x)->fn;
|
||||
// nx->num_args = ((closureN) x)->num_args;
|
||||
// nx->num_elt = ((closureN) x)->num_elt;
|
||||
// nx->elts = (object *)(((char *)nx) + sizeof(closureN_type));
|
||||
// for (i = 0; i < nx->num_elt; i++) {
|
||||
// nx->elts[i] = ((closureN) x)->elts[i];
|
||||
// }
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(closureN_type) + sizeof(object) * nx->num_elt;
|
||||
// return (char *) nx;}
|
||||
// case vector_tag:
|
||||
// {register vector nx = (vector) allocp;
|
||||
// int i;
|
||||
// type_of(nx) = vector_tag;
|
||||
// nx->num_elt = ((vector) x)->num_elt;
|
||||
// nx->elts = (object *)(((char *)nx) + sizeof(vector_type));
|
||||
// for (i = 0; i < nx->num_elt; i++) {
|
||||
// nx->elts[i] = ((vector) x)->elts[i];
|
||||
// }
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(vector_type) + sizeof(object) * nx->num_elt;
|
||||
// return (char *) nx;}
|
||||
// case string_tag:
|
||||
// {register string_type *nx = (string_type *) allocp;
|
||||
// int str_size = gc_word_align(((string_type *)x)->len + 1);
|
||||
// type_of(nx) = string_tag;
|
||||
// nx->len = ((string_type *)x)->len;
|
||||
// nx->str = ((char *)nx) + sizeof(string_type);
|
||||
// memcpy(nx->str, ((string_type *)x)->str, nx->len + 1);
|
||||
////TODO: below is changing, now we will need to always copy the cstring
|
||||
////along with the string_type. need to be careful of any off-by-one errors
|
||||
////here...
|
||||
//// if (gcgen == 0) {
|
||||
//// // Minor, data heap is not relocated
|
||||
//// nx->str = ((string_type *)x)->str;
|
||||
//// } else {
|
||||
//// // Major collection, data heap is moving
|
||||
//// nx->str = dhallocp;
|
||||
//// int len = strlen(((string_type *) x)->str);
|
||||
//// memcpy(dhallocp, ((string_type *) x)->str, len + 1);
|
||||
//// dhallocp += len + 1;
|
||||
//// }
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(string_type)+str_size;
|
||||
// return (char *) nx;}
|
||||
// case integer_tag:
|
||||
// {register integer_type *nx = (integer_type *) allocp;
|
||||
// type_of(nx) = integer_tag; nx->value = ((integer_type *) x)->value;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(integer_type);
|
||||
// return (char *) nx;}
|
||||
// case double_tag:
|
||||
// {register double_type *nx = (double_type *) allocp;
|
||||
// type_of(nx) = double_tag; nx->value = ((double_type *) x)->value;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(double_type);
|
||||
// return (char *) nx;}
|
||||
// case port_tag:
|
||||
// {register port_type *nx = (port_type *) allocp;
|
||||
// type_of(nx) = port_tag; nx->fp = ((port_type *) x)->fp;
|
||||
// nx->mode = ((port_type *) x)->mode;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(port_type);
|
||||
// return (char *) nx;}
|
||||
// case cvar_tag:
|
||||
// {register cvar_type *nx = (cvar_type *) allocp;
|
||||
// type_of(nx) = cvar_tag; nx->pvar = ((cvar_type *) x)->pvar;
|
||||
// forward(x) = nx; type_of(x) = forward_tag;
|
||||
// x = (char *) nx; allocp = ((char *) nx)+sizeof(cvar_type);
|
||||
// return (char *) nx;}
|
||||
// case forward_tag:
|
||||
// return (char *) forward(x);
|
||||
// case eof_tag: break;
|
||||
// case primitive_tag: break;
|
||||
// case boolean_tag: break;
|
||||
// case symbol_tag: break; // JAE TODO: raise an error here? Should not be possible in real code, though (IE, without GC DEBUG flag)
|
||||
// default:
|
||||
// printf("transport: bad tag x=%p x.tag=%ld\n",(void *)x,type_of(x)); exit(0);}
|
||||
// return x;}
|
||||
//
|
||||
///* Use overflow macro which already knows which way the stack goes. */
|
||||
///* Major collection, transport objects on stack or old heap */
|
||||
//#define transp(p) \
|
||||
//temp = (p); \
|
||||
//if ((check_overflow(low_limit,temp) && \
|
||||
// check_overflow(temp,high_limit)) || \
|
||||
// (check_overflow(old_heap_low_limit - 1, temp) && \
|
||||
// check_overflow(temp,old_heap_high_limit + 1))) \
|
||||
// (p) = (object) transport(temp,major);
|
||||
//
|
||||
//void GC_loop(int major, closure cont, object *ans, int num_ans)
|
||||
//{char foo;
|
||||
// int i;
|
||||
// register object temp;
|
||||
// register object low_limit = &foo; /* Move live data above us. */
|
||||
// register object high_limit = stack_begin;
|
||||
// register char *scanp = allocp; /* Cheney scan pointer. */
|
||||
// register object old_heap_low_limit = low_limit; // Minor-GC default
|
||||
// register object old_heap_high_limit = high_limit; // Minor-GC default
|
||||
//
|
||||
// char *tmp_bottom = bottom; /* Bottom of tospace. */
|
||||
// char *tmp_allocp = allocp; /* Cheney allocate pointer. */
|
||||
// char *tmp_alloc_end = alloc_end;
|
||||
// char *tmp_dhbottom = dhbottom;
|
||||
// char *tmp_dhallocp = dhallocp;
|
||||
// char *tmp_dhallocp_end = dhalloc_end;
|
||||
//
|
||||
// if (dhallocp > dhalloc_limit) {
|
||||
// // Upgrade to major GC
|
||||
// major = 1;
|
||||
// no_major_gcs++;
|
||||
// no_gcs--;
|
||||
// }
|
||||
//
|
||||
// if (major) {
|
||||
// // Initialize new heap (TODO: make a function for this)
|
||||
// bottom = calloc(1,global_heap_size);
|
||||
// allocp = (char *) ((((long) bottom)+7) & -8);
|
||||
// alloc_end = allocp + global_heap_size - 8;
|
||||
// scanp = allocp;
|
||||
// old_heap_low_limit = tmp_bottom;
|
||||
// old_heap_high_limit = tmp_alloc_end;
|
||||
//
|
||||
// dhallocp = dhbottom = calloc(1, global_heap_size);
|
||||
// dhalloc_limit = dhallocp + (long)((global_heap_size - 8) * 0.90);
|
||||
// dhalloc_end = dhallocp + global_heap_size - 8;
|
||||
// }
|
||||
//
|
||||
//#if DEBUG_GC
|
||||
// printf("\n=== started GC type = %d === \n", major);
|
||||
//#endif
|
||||
// /* Transport GC's continuation and its argument. */
|
||||
// transp(cont);
|
||||
// gc_cont = cont;
|
||||
// gc_num_ans = num_ans;
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG done transporting cont\n");
|
||||
//#endif
|
||||
//
|
||||
// /* Prevent overrunning buffer */
|
||||
// if (num_ans > NUM_GC_ANS) {
|
||||
// printf("Fatal error - too many arguments (%d) to GC\n", num_ans);
|
||||
// exit(1);
|
||||
// }
|
||||
//
|
||||
// for (i = 0; i < num_ans; i++){
|
||||
// transp(ans[i]);
|
||||
// gc_ans[i] = ans[i];
|
||||
// }
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG done transporting gc_ans\n");
|
||||
//#endif
|
||||
//
|
||||
// /* Transport mutations. */
|
||||
// {
|
||||
// list l;
|
||||
// for (l = mutation_table; !nullp(l); l = cdr(l)) {
|
||||
// object o = car(l);
|
||||
// if (type_of(o) == cons_tag) {
|
||||
// // Transport, if necessary
|
||||
// // TODO: need to test this with major GC, and
|
||||
// // GC's of list/car-cdr from same generation
|
||||
// transp(car(o));
|
||||
// transp(cdr(o));
|
||||
// } else if (type_of(o) == vector_tag) {
|
||||
// int i;
|
||||
// // TODO: probably too inefficient, try collecting single index
|
||||
// for (i = 0; i < ((vector)o)->num_elt; i++) {
|
||||
// transp(((vector)o)->elts[i]);
|
||||
// }
|
||||
// } else if (type_of(o) == forward_tag) {
|
||||
// // Already transported, skip
|
||||
// } else {
|
||||
// printf("Unexpected type %ld transporting mutation\n", type_of(o));
|
||||
// exit(1);
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// clear_mutations(); /* Reset for next time */
|
||||
//
|
||||
// /* Transport global variables. */
|
||||
// transp(Cyc_global_variables); /* Internal global used by the runtime */
|
||||
// {
|
||||
// list l = global_table;
|
||||
// for(; !nullp(l); l = cdr(l)){
|
||||
// cvar_type *c = (cvar_type *)car(l);
|
||||
// transp(*(c->pvar)); // GC global, not the pvar
|
||||
// }
|
||||
// }
|
||||
// while (scanp<allocp) /* Scan the newspace. */
|
||||
// switch (type_of(scanp))
|
||||
// {case cons_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport cons_tag\n");
|
||||
//#endif
|
||||
// transp(car(scanp)); transp(cdr(scanp));
|
||||
// scanp += sizeof(cons_type); break;
|
||||
// case macro_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport macro \n");
|
||||
//#endif
|
||||
// scanp += sizeof(macro_type); break;
|
||||
// case closure0_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport closure0 \n");
|
||||
//#endif
|
||||
// scanp += sizeof(closure0_type); break;
|
||||
// case closure1_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport closure1 \n");
|
||||
//#endif
|
||||
// transp(((closure1) scanp)->elt1);
|
||||
// scanp += sizeof(closure1_type); break;
|
||||
// case closure2_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport closure2 \n");
|
||||
//#endif
|
||||
// transp(((closure2) scanp)->elt1); transp(((closure2) scanp)->elt2);
|
||||
// scanp += sizeof(closure2_type); break;
|
||||
// case closure3_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport closure3 \n");
|
||||
//#endif
|
||||
// transp(((closure3) scanp)->elt1); transp(((closure3) scanp)->elt2);
|
||||
// transp(((closure3) scanp)->elt3);
|
||||
// scanp += sizeof(closure3_type); break;
|
||||
// case closure4_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport closure4 \n");
|
||||
//#endif
|
||||
// transp(((closure4) scanp)->elt1); transp(((closure4) scanp)->elt2);
|
||||
// transp(((closure4) scanp)->elt3); transp(((closure4) scanp)->elt4);
|
||||
// scanp += sizeof(closure4_type); break;
|
||||
// case closureN_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport closureN \n");
|
||||
//#endif
|
||||
// {int i; int n = ((closureN) scanp)->num_elt;
|
||||
// for (i = 0; i < n; i++) {
|
||||
// transp(((closureN) scanp)->elts[i]);
|
||||
// }
|
||||
// scanp += sizeof(closureN_type) + sizeof(object) * n;
|
||||
// }
|
||||
// break;
|
||||
// case vector_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport vector \n");
|
||||
//#endif
|
||||
// {int i; int n = ((vector) scanp)->num_elt;
|
||||
// for (i = 0; i < n; i++) {
|
||||
// transp(((vector) scanp)->elts[i]);
|
||||
// }
|
||||
// scanp += sizeof(vector_type) + sizeof(object) * n;
|
||||
// }
|
||||
// break;
|
||||
// case string_tag: {
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport string \n");
|
||||
//#endif
|
||||
// string_type *x = (string_type *)scanp;
|
||||
// scanp += sizeof(string_type);
|
||||
// scanp += gc_word_align(x->len + 1);
|
||||
// break;
|
||||
// }
|
||||
////TODO: cstring is now after string_type, so need to skip that, too.
|
||||
////stack allocations should be OK since we are only scanning the newspace here,
|
||||
////but should double-check that... (though we are not able to even scan the
|
||||
////stack so should be fine)
|
||||
// case integer_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport integer \n");
|
||||
//#endif
|
||||
// scanp += sizeof(integer_type); break;
|
||||
// case double_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport double \n");
|
||||
//#endif
|
||||
// scanp += sizeof(double_type); break;
|
||||
// case port_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport port \n");
|
||||
//#endif
|
||||
// scanp += sizeof(port_type); break;
|
||||
// case cvar_tag:
|
||||
//#if DEBUG_GC
|
||||
// printf("DEBUG transport cvar \n");
|
||||
//#endif
|
||||
// scanp += sizeof(cvar_type); break;
|
||||
// case eof_tag:
|
||||
// case primitive_tag:
|
||||
// case symbol_tag:
|
||||
// case boolean_tag:
|
||||
// default:
|
||||
// printf("GC: bad tag scanp=%p scanp.tag=%ld\n",(void *)scanp,type_of(scanp));
|
||||
// exit(0);}
|
||||
//
|
||||
// if (major) {
|
||||
// free(tmp_bottom);
|
||||
// free(tmp_dhbottom);
|
||||
// }
|
||||
//}
|
||||
//
|
||||
//void GC(cont,ans,num_ans) closure cont; object *ans; int num_ans;
|
||||
//{
|
||||
// /* Only room for one more minor-GC, so do a major one.
|
||||
// * Not sure this is the best strategy, it may be better to do major
|
||||
// * ones sooner, perhaps after every x minor GC's.
|
||||
// *
|
||||
// * Also may need to consider dynamically increasing heap size, but
|
||||
// * by how much (1.3x, 1.5x, etc) and when? I suppose when heap usage
|
||||
// * after a collection is above a certain percentage, then it would be
|
||||
// * necessary to increase heap size the next time.
|
||||
// */
|
||||
// if (allocp >= (bottom + (global_heap_size - global_stack_size))) {
|
||||
// //printf("Possibly only room for one more minor GC. no_gcs = %ld\n", no_gcs);
|
||||
// no_major_gcs++;
|
||||
// GC_loop(1, cont, ans, num_ans);
|
||||
// } else {
|
||||
// no_gcs++; /* Count the number of minor GC's. */
|
||||
// GC_loop(0, cont, ans, num_ans);
|
||||
// }
|
||||
//
|
||||
// /* You have to let it all go, Neo. Fear, doubt, and disbelief. Free your mind... */
|
||||
// longjmp(jmp_main,1); /* Return globals gc_cont, gc_ans. */
|
||||
//}
|
||||
|
||||
/**
|
||||
* Start a thread's trampoline
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue