48 |
{ |
{ |
49 |
int i; |
int i; |
50 |
|
|
51 |
env->gc_limit= 200; |
env->gc_limit= 400000; |
52 |
env->gc_count= 0; |
env->gc_count= 0; |
53 |
env->gc_ref= NULL; |
env->gc_ref= NULL; |
54 |
|
|
80 |
|
|
81 |
env->head= env->head->next; /* Remove the top stack item */ |
env->head= env->head->next; /* Remove the top stack item */ |
82 |
free(temp); /* Free the old top stack item */ |
free(temp); /* Free the old top stack item */ |
|
|
|
|
env->gc_limit--; |
|
83 |
} |
} |
84 |
|
|
85 |
/* Returns a pointer to a pointer to an element in the hash table. */ |
/* Returns a pointer to a pointer to an element in the hash table. */ |
123 |
nitem->next= env->gc_ref; |
nitem->next= env->gc_ref; |
124 |
env->gc_ref= nitem; |
env->gc_ref= nitem; |
125 |
|
|
126 |
env->gc_count++; |
env->gc_count+=sizeof(value); |
127 |
nval->gc_garb= 1; |
nval->gc.flag.mark= 0; |
128 |
|
nval->gc.flag.protect= 0; |
129 |
|
|
130 |
return nval; |
return nval; |
131 |
} |
} |
136 |
{ |
{ |
137 |
stackitem *iterator; |
stackitem *iterator; |
138 |
|
|
139 |
if(val->gc_garb==0) |
if(val->gc.flag.mark) |
140 |
return; |
return; |
141 |
|
|
142 |
val->gc_garb= 0; |
val->gc.flag.mark= 1; |
143 |
|
|
144 |
if(val->type==list) { |
if(val->type==list) { |
145 |
iterator= val->content.ptr; |
iterator= val->content.ptr; |
166 |
symbol *tsymb; |
symbol *tsymb; |
167 |
int i; |
int i; |
168 |
|
|
169 |
|
if(env->interactive){ |
170 |
|
printf("Garbage collecting.", env->gc_count, env->gc_limit); |
171 |
|
} |
172 |
|
|
173 |
/* Mark values on stack */ |
/* Mark values on stack */ |
174 |
iterator= env->head; |
iterator= env->head; |
175 |
while(iterator!=NULL) { |
while(iterator!=NULL) { |
177 |
iterator= iterator->next; |
iterator= iterator->next; |
178 |
} |
} |
179 |
|
|
180 |
|
if(env->interactive){ |
181 |
|
printf("."); |
182 |
|
} |
183 |
|
|
184 |
/* Mark values in hashtable */ |
/* Mark values in hashtable */ |
185 |
for(i= 0; i<HASHTBLSIZE; i++) { |
for(i= 0; i<HASHTBLSIZE; i++) { |
186 |
tsymb= env->symbols[i]; |
tsymb= env->symbols[i]; |
191 |
} |
} |
192 |
} |
} |
193 |
|
|
194 |
|
if(env->interactive){ |
195 |
|
printf("."); |
196 |
|
} |
197 |
|
|
198 |
env->gc_count= 0; |
env->gc_count= 0; |
199 |
|
|
200 |
while(env->gc_ref!=NULL) { /* Sweep unused values */ |
while(env->gc_ref!=NULL) { /* Sweep unused values */ |
201 |
|
|
202 |
if(env->gc_ref->item->gc_garb |
if(!(env->gc_ref->item->gc.no_gc)){ /* neither mark nor protect */ |
|
&& !(env->gc_ref->item->gc_protect)) { |
|
203 |
|
|
204 |
switch(env->gc_ref->item->type) { /* Remove content */ |
switch(env->gc_ref->item->type) { /* Remove content */ |
205 |
case string: |
case string: |
218 |
free(env->gc_ref); /* Remove value */ |
free(env->gc_ref); /* Remove value */ |
219 |
env->gc_ref= titem; |
env->gc_ref= titem; |
220 |
continue; |
continue; |
221 |
|
} else { |
222 |
|
env->gc_count += sizeof(value); |
223 |
} |
} |
224 |
|
|
225 |
/* Keep values */ |
/* Keep values */ |
226 |
titem= env->gc_ref->next; |
titem= env->gc_ref->next; |
227 |
env->gc_ref->next= new_head; |
env->gc_ref->next= new_head; |
228 |
new_head= env->gc_ref; |
new_head= env->gc_ref; |
229 |
new_head->item->gc_garb= 1; |
new_head->item->gc.flag.mark= 0; |
230 |
env->gc_ref= titem; |
env->gc_ref= titem; |
|
env->gc_count++; |
|
231 |
} |
} |
232 |
|
|
233 |
env->gc_limit= env->gc_count*2; |
if (env->gc_limit < env->gc_count*2) |
234 |
|
env->gc_limit= env->gc_count*2; |
235 |
env->gc_ref= new_head; |
env->gc_ref= new_head; |
236 |
|
|
237 |
|
if(env->interactive){ |
238 |
|
printf("done\n"); |
239 |
|
} |
240 |
|
|
241 |
} |
} |
242 |
|
|
243 |
/* Protect values from GC */ |
/* Protect values from GC */ |
245 |
{ |
{ |
246 |
stackitem *iterator; |
stackitem *iterator; |
247 |
|
|
248 |
if(val->gc_protect) |
if(val->gc.flag.protect) |
249 |
return; |
return; |
250 |
|
|
251 |
val->gc_protect= 1; |
val->gc.flag.protect= 1; |
252 |
|
|
253 |
if(val->type==list) { |
if(val->type==list) { |
254 |
iterator= val->content.ptr; |
iterator= val->content.ptr; |
265 |
{ |
{ |
266 |
stackitem *iterator; |
stackitem *iterator; |
267 |
|
|
268 |
if(!(val->gc_protect)) |
if(!(val->gc.flag.protect)) |
269 |
return; |
return; |
270 |
|
|
271 |
val->gc_protect= 0; |
val->gc.flag.protect= 0; |
272 |
|
|
273 |
if(val->type==list) { |
if(val->type==list) { |
274 |
iterator= val->content.ptr; |
iterator= val->content.ptr; |
679 |
push_val(env, iterator->item); |
push_val(env, iterator->item); |
680 |
|
|
681 |
if(env->head->item->type==symb |
if(env->head->item->type==symb |
682 |
&& strcmp(";", ((symbol*)(env->head->item->content.ptr))->id)==0) { |
&& (((symbol*)(env->head->item->content.ptr))->id[0] == ';')) { |
683 |
toss(env); |
toss(env); |
684 |
if(env->err) return; |
if(env->err) return; |
685 |
|
|