Back to index

plt-scheme  4.2.1
mzmarksrc.c
Go to the documentation of this file.
00001 
00002 START type;
00003 
00004 variable_obj {
00005  mark:
00006   Scheme_Bucket *b = (Scheme_Bucket *)p;
00007 
00008   gcMARK(b->key);
00009   gcMARK(b->val);
00010   gcMARK(((Scheme_Bucket_With_Home *)b)->home);
00011 
00012  size:
00013   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home));
00014 }
00015 
00016 module_var {
00017  mark:
00018   Module_Variable *mv = (Module_Variable *)p;
00019 
00020   gcMARK(mv->modidx);
00021   gcMARK(mv->sym);
00022   gcMARK(mv->insp);
00023 
00024  size:
00025   gcBYTES_TO_WORDS(sizeof(Module_Variable));
00026 }
00027 
00028 bucket_obj {
00029  mark:
00030   Scheme_Bucket *b = (Scheme_Bucket *)p;
00031 
00032   gcMARK(b->key);
00033   gcMARK(b->val);
00034 
00035  size:
00036   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket));
00037 }
00038 
00039 local_obj {
00040  mark:
00041  size:
00042   gcBYTES_TO_WORDS(sizeof(Scheme_Local));
00043 }
00044 
00045 toplevel_obj {
00046  mark:
00047  size:
00048   gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel));
00049 }
00050 
00051 quotesyntax_obj {
00052  mark:
00053  size:
00054   gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax));
00055 }
00056 
00057 cpointer_obj {
00058  mark:
00059   gcMARK(SCHEME_CPTR_VAL(p));
00060   gcMARK(SCHEME_CPTR_TYPE(p));
00061  size:
00062   gcBYTES_TO_WORDS(sizeof(Scheme_Cptr));
00063 }
00064 
00065 offset_cpointer_obj {
00066  mark:
00067   gcMARK(SCHEME_CPTR_VAL(p));
00068   gcMARK(SCHEME_CPTR_TYPE(p));
00069  size:
00070   gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr));
00071 }
00072 
00073 second_of_cons {
00074  mark:
00075   gcMARK(SCHEME_PTR2_VAL((Scheme_Object *)p));
00076  size:
00077   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00078 }
00079 
00080 twoptr_obj {
00081  mark:
00082   gcMARK(SCHEME_PTR1_VAL((Scheme_Object *)p));
00083   gcMARK(SCHEME_PTR2_VAL((Scheme_Object *)p));
00084  size:
00085   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00086 }
00087 
00088 iptr_obj {
00089  mark:
00090   gcMARK(SCHEME_IPTR_VAL((Scheme_Object *)p));
00091  size:
00092   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00093 }
00094 
00095 small_object {
00096  mark:
00097   gcMARK(((Scheme_Small_Object *)p)->u.ptr_value);
00098 
00099  size:
00100   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
00101 }
00102 
00103 app_rec {
00104   Scheme_App_Rec *r = (Scheme_App_Rec *)p;
00105 
00106  mark:
00107   int i = r->num_args + 1;
00108   while (i--) 
00109     gcMARK(r->args[i]);
00110 
00111  size:
00112   gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 
00113                   + (r->num_args * sizeof(Scheme_Object *))
00114                   + ((r->num_args + 1) * sizeof(char))));
00115 }
00116 
00117 app2_rec {
00118  mark:
00119   Scheme_App2_Rec *r = (Scheme_App2_Rec *)p;
00120   gcMARK(r->rator);
00121   gcMARK(r->rand);
00122 
00123  size:
00124   gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec));
00125 }
00126 
00127 app3_rec {
00128  mark:
00129   Scheme_App3_Rec *r = (Scheme_App3_Rec *)p;
00130   gcMARK(r->rator);
00131   gcMARK(r->rand1);
00132   gcMARK(r->rand2);
00133 
00134  size:
00135   gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec));
00136 }
00137 
00138 seq_rec {
00139   Scheme_Sequence *s = (Scheme_Sequence *)p;
00140 
00141  mark:
00142   int i = s->count;
00143   while (i--)
00144     gcMARK(s->array[i]);
00145 
00146  size:
00147   gcBYTES_TO_WORDS((sizeof(Scheme_Sequence)
00148                   + ((s->count - 1) * sizeof(Scheme_Object *))));
00149 }
00150 
00151 branch_rec {
00152  mark:
00153   Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p;
00154   
00155   gcMARK(b->test);
00156   gcMARK(b->tbranch);
00157   gcMARK(b->fbranch);
00158 
00159  size:
00160   gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec));
00161 }
00162 
00163 unclosed_proc {
00164  mark:
00165   Scheme_Closure_Data *d = (Scheme_Closure_Data *)p;
00166 
00167   gcMARK(d->name);
00168   gcMARK(d->code);
00169   gcMARK(d->closure_map);
00170 #ifdef MZ_USE_JIT
00171   gcMARK(d->u.native_code);
00172   gcMARK(d->context);
00173 #endif
00174 
00175  size:
00176   gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data));
00177 }
00178 
00179 let_value {
00180  mark:
00181   Scheme_Let_Value *l = (Scheme_Let_Value *)p;
00182   
00183   gcMARK(l->value);
00184   gcMARK(l->body);
00185 
00186  size:
00187   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value));
00188 }
00189 
00190 let_void {
00191  mark:
00192   Scheme_Let_Void *l = (Scheme_Let_Void *)p;
00193 
00194   gcMARK(l->body);
00195   
00196  size:
00197   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void));
00198 }
00199 
00200 letrec {
00201  mark:
00202   Scheme_Letrec *l = (Scheme_Letrec *)p;
00203   
00204   gcMARK(l->procs);
00205   gcMARK(l->body);
00206 
00207  size:
00208   gcBYTES_TO_WORDS(sizeof(Scheme_Letrec));
00209 }
00210 
00211 let_one {
00212  mark:
00213   Scheme_Let_One *l = (Scheme_Let_One *)p;
00214   
00215   gcMARK(l->value);
00216   gcMARK(l->body);
00217 
00218  size:
00219   gcBYTES_TO_WORDS(sizeof(Scheme_Let_One));
00220 }
00221 
00222 with_cont_mark {
00223  mark:
00224   Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p;
00225 
00226   gcMARK(w->key);
00227   gcMARK(w->val);
00228   gcMARK(w->body);
00229 
00230  size:
00231   gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark));
00232 }
00233 
00234 comp_let_value {
00235  mark:
00236   Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p;
00237 
00238   gcMARK(c->flags);
00239   gcMARK(c->value);
00240   gcMARK(c->body);
00241 
00242  size:
00243   gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value));
00244 }
00245 
00246 let_header {
00247  mark:
00248   Scheme_Let_Header *h = (Scheme_Let_Header *)p;
00249   
00250   gcMARK(h->body);
00251 
00252  size:
00253   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header));
00254 }
00255 
00256 prim_proc {
00257   Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p;
00258 
00259  mark:
00260   gcMARK(prim->name);
00261   if (prim->mina < 0) {
00262     gcMARK(prim->mu.cases);
00263   }
00264   if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) {
00265     Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim;
00266     int i;
00267     for (i = cc->count; i--; ) {
00268       gcMARK(cc->val[i]);
00269     }
00270   }  
00271   
00272  size:
00273   ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE)
00274    ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure))
00275       + ((Scheme_Primitive_Closure *)prim)->count - 1)
00276    : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00277       ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity))
00278       : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc))));
00279 }
00280 
00281 closed_prim_proc {
00282   Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p;
00283 
00284  mark:
00285   gcMARK(c->name);
00286   gcMARK(SCHEME_CLSD_PRIM_DATA(c));
00287   if (c->mina == -2) {
00288     gcMARK(((Scheme_Closed_Case_Primitive_Proc *)c)->cases);
00289   }
00290   
00291  size:
00292   ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00293    ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity))
00294    : ((c->mina == -2)
00295       ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc))
00296       : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc))));
00297 }
00298 
00299 scm_closure {
00300   Scheme_Closure *c = (Scheme_Closure *)p;
00301   int closure_size = (c->code 
00302                       ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size
00303                       : 0);
00304 
00305  mark:
00306 
00307   int i = closure_size;
00308   while (i--)
00309     gcMARK(c->vals[i]);
00310   gcMARK(c->code);
00311   
00312  size:
00313   gcBYTES_TO_WORDS((sizeof(Scheme_Closure)
00314                   + (closure_size - 1) * sizeof(Scheme_Object *)));
00315 }
00316 
00317 case_closure {
00318   Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p;
00319 
00320  mark:
00321   int i;
00322   
00323   for (i = c->count; i--; )
00324     gcMARK(c->array[i]);
00325   gcMARK(c->name);
00326 #ifdef MZ_USE_JIT
00327   gcMARK(c->native_code);
00328 #endif
00329 
00330  size:
00331   gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda)
00332                   + ((c->count - 1) * sizeof(Scheme_Object *))));
00333 }
00334 
00335 cont_proc {
00336  mark:
00337   Scheme_Cont *c = (Scheme_Cont *)p;
00338   
00339   gcMARK(c->dw);
00340   gcMARK(c->prompt_tag);
00341   gcMARK(c->meta_continuation);
00342   gcMARK(c->common_dw);
00343   gcMARK(c->save_overflow);
00344   gcMARK(c->runstack_copied);
00345   gcMARK(c->runstack_owner);
00346   gcMARK(c->cont_mark_stack_copied);
00347   gcMARK(c->cont_mark_stack_owner);
00348   gcMARK(c->init_config);
00349   gcMARK(c->init_break_cell);
00350 #ifdef MZ_USE_JIT
00351   gcMARK(c->native_trace);
00352 #endif
00353 
00354   MARK_jmpup(&c->buf);
00355   MARK_cjs(&c->cjs);
00356   MARK_stack_state(&c->ss);
00357   gcMARK(c->barrier_prompt);
00358   if (!GC_merely_accounting()) {
00359     gcMARK(c->runstack_start);
00360     gcMARK(c->runstack_saved);
00361   }
00362 
00363   gcMARK(c->prompt_id);
00364   gcMARK(c->prompt_buf);
00365 
00366   gcMARK(c->value);
00367   gcMARK(c->resume_to);
00368   gcMARK(c->use_next_cont);
00369   gcMARK(c->extra_marks);
00370   gcMARK(c->shortcut_prompt);
00371   
00372  size:
00373   gcBYTES_TO_WORDS(sizeof(Scheme_Cont));
00374 }
00375 
00376 meta_cont_proc {
00377  mark:
00378   Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p;
00379   
00380   gcMARK(c->prompt_tag);
00381   gcMARK(c->overflow);
00382   gcMARK(c->next);
00383   gcMARK(c->cont_mark_stack_copied);
00384   gcMARK(c->cont);
00385 
00386  size:
00387   gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation));
00388 }
00389 
00390 mark_dyn_wind {
00391  mark:
00392   Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p;
00393   
00394   gcMARK(dw->id);
00395   gcMARK(dw->data);
00396   gcMARK(dw->prompt_tag);
00397   gcMARK(dw->prev);
00398     
00399   MARK_stack_state(&dw->envss);
00400 
00401  size:
00402   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind));
00403 }
00404 
00405 mark_overflow {
00406  mark:
00407   Scheme_Overflow *o = (Scheme_Overflow *)p;
00408 
00409   gcMARK(o->prev);
00410   gcMARK(o->jmp);
00411   gcMARK(o->id);
00412 
00413  size:
00414   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow));
00415 }
00416 
00417 mark_overflow_jmp {
00418  mark:
00419   Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p;
00420 
00421   MARK_jmpup(&o->cont);
00422 
00423  size:
00424   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp));
00425 }
00426 
00427 escaping_cont_proc {
00428  mark:
00429   Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p;
00430 
00431 #ifdef MZ_USE_JIT
00432   gcMARK(c->native_trace);
00433 #endif
00434 
00435   gcMARK(c->barrier_prompt);
00436   MARK_stack_state(&c->envss);
00437 
00438  size:
00439   gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont));
00440 }
00441 
00442 char_obj {
00443  mark:
00444  size:
00445   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
00446 }
00447 
00448 bignum_obj {
00449   Scheme_Bignum *b = (Scheme_Bignum *)p;
00450 
00451  mark:
00452   if (!SCHEME_BIGINLINE(b)) {
00453     gcMARK(b->digits);
00454   } else {
00455     FIXUP_ONLY(b->digits = ((Small_Bignum *)GC_fixup_self(b))->v;)
00456   }
00457 
00458  size:
00459   ((!SCHEME_BIGINLINE(b))
00460    ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum))
00461    : gcBYTES_TO_WORDS(sizeof(Small_Bignum)));
00462 }
00463 
00464 rational_obj {
00465  mark:
00466   Scheme_Rational *r = (Scheme_Rational *)p;
00467   
00468   gcMARK(r->num);
00469   gcMARK(r->denom);
00470 
00471  size:
00472   gcBYTES_TO_WORDS(sizeof(Scheme_Rational));
00473 }
00474 
00475 float_obj {
00476  mark:
00477  size:
00478 #ifdef MZ_USE_SINGLE_FLOATS
00479   gcBYTES_TO_WORDS(sizeof(Scheme_Float));
00480 #else
00481   0;
00482 #endif
00483 }
00484 
00485 double_obj {
00486  mark:
00487  size:
00488   gcBYTES_TO_WORDS(sizeof(Scheme_Double));
00489 }
00490 
00491 complex_obj {
00492  mark:
00493   Scheme_Complex *c = (Scheme_Complex *)p;
00494   
00495   gcMARK(c->r);
00496   gcMARK(c->i);
00497   
00498  size:
00499   gcBYTES_TO_WORDS(sizeof(Scheme_Complex));
00500 }
00501 
00502 string_obj {
00503  mark:
00504   Scheme_Object *o = (Scheme_Object *)p;
00505   gcMARK(SCHEME_CHAR_STR_VAL(o));
00506 
00507  size:
00508   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00509 }
00510 
00511 bstring_obj {
00512  mark:
00513   Scheme_Object *o = (Scheme_Object *)p;
00514   gcMARK(SCHEME_BYTE_STR_VAL(o));
00515 
00516  size:
00517   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00518 }
00519 
00520 symbol_obj {
00521   Scheme_Symbol *s = (Scheme_Symbol *)p;
00522 
00523  mark:
00524  size:
00525   gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len - 3);
00526 }
00527 
00528 cons_cell {
00529  mark:
00530   Scheme_Object *o = (Scheme_Object *)p;
00531   
00532   gcMARK(SCHEME_CAR(o));
00533   gcMARK(SCHEME_CDR(o));
00534 
00535  size:
00536   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00537 }
00538 
00539 vector_obj {
00540   Scheme_Vector *vec = (Scheme_Vector *)p;
00541 
00542  mark:
00543   int i;
00544   for (i = vec->size; i--; )
00545     gcMARK(vec->els[i]);
00546 
00547  size:
00548   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
00549                   + ((vec->size - 1) * sizeof(Scheme_Object *))));
00550 }
00551 
00552 input_port {
00553  mark:
00554   Scheme_Input_Port *ip = (Scheme_Input_Port *)p;
00555   
00556   gcMARK(ip->sub_type);
00557   gcMARK(ip->port_data);
00558   gcMARK(ip->name);
00559   gcMARK(ip->peeked_read);
00560   gcMARK(ip->peeked_write);
00561   gcMARK(ip->read_handler);
00562   gcMARK(ip->mref);
00563   gcMARK(ip->output_half);
00564   gcMARK(ip->special);
00565   gcMARK(ip->ungotten_special);
00566   gcMARK(ip->progress_evt);
00567   gcMARK(ip->input_lock);
00568   gcMARK(ip->input_giveup);
00569   gcMARK(ip->input_extras);
00570   gcMARK(ip->input_extras_ready);
00571   gcMARK(ip->unless);
00572   gcMARK(ip->unless_cache);
00573 
00574  size:
00575   gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port));
00576 }
00577 
00578 output_port {
00579  mark:
00580   Scheme_Output_Port *op = (Scheme_Output_Port *)p;
00581 
00582   gcMARK(op->sub_type);
00583   gcMARK(op->port_data);
00584   gcMARK(op->name);
00585   gcMARK(op->display_handler);
00586   gcMARK(op->write_handler);
00587   gcMARK(op->print_handler);
00588   gcMARK(op->mref);
00589   gcMARK(op->input_half);
00590 
00591  size:
00592   gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port));
00593 }
00594 
00595 
00596 syntax_compiler {
00597  mark:
00598  size:
00599   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00600 }
00601 
00602 thread_val {
00603  mark:
00604   Scheme_Thread *pr = (Scheme_Thread *)p;
00605   
00606   gcMARK(pr->next);
00607   gcMARK(pr->prev);
00608 
00609   gcMARK(pr->t_set_parent);
00610   gcMARK(pr->t_set_next);
00611   gcMARK(pr->t_set_prev);
00612 
00613   MARK_cjs(&pr->cjs);
00614   gcMARK(pr->decompose_mc);
00615 
00616   gcMARK(pr->cell_values);
00617   gcMARK(pr->init_config);
00618   gcMARK(pr->init_break_cell);
00619 
00620   if (!pr->runstack_owner
00621       || !GC_merely_accounting()
00622       || (*pr->runstack_owner == pr)) {
00623     Scheme_Object **rs = pr->runstack_start;
00624     gcFIXUP_TYPED_NOW(Scheme_Object **, pr->runstack_start);
00625     if (pr->runstack != pr->runstack_start + (pr->runstack - rs))
00626       pr->runstack = pr->runstack_start + (pr->runstack - rs);
00627 
00628     gcMARK(pr->runstack_saved);
00629   }
00630   gcMARK(pr->runstack_owner);
00631   gcMARK(pr->runstack_swapped);
00632   pr->spare_runstack = NULL; /* just in case */
00633 
00634   gcMARK(pr->meta_prompt);
00635   gcMARK(pr->meta_continuation);
00636   
00637   gcMARK(pr->cont_mark_stack_segments);
00638   gcMARK(pr->cont_mark_stack_owner);
00639   gcMARK(pr->cont_mark_stack_swapped);
00640 
00641   MARK_jmpup(&pr->jmpup_buf);
00642   
00643   gcMARK(pr->dw);
00644   
00645   gcMARK(pr->nester);
00646   gcMARK(pr->nestee);
00647   
00648   gcMARK(pr->blocker);
00649   gcMARK(pr->overflow);
00650 
00651   gcMARK(pr->return_marks_to);
00652   gcMARK(pr->returned_marks);
00653   
00654   gcMARK(pr->current_local_env);
00655   gcMARK(pr->current_local_mark);
00656   gcMARK(pr->current_local_name);
00657   gcMARK(pr->current_local_certs);
00658   gcMARK(pr->current_local_modidx);
00659   gcMARK(pr->current_local_menv);
00660   gcMARK(pr->current_local_bindings);
00661 
00662   gcMARK(pr->current_mt);
00663 
00664   gcMARK(pr->constant_folding);
00665   gcMARK(pr->reading_delayed);
00666   
00667   gcMARK(pr->overflow_reply);
00668 
00669   gcMARK(pr->values_buffer);
00670 
00671   gcMARK(pr->tail_buffer);
00672   
00673   gcMARK(pr->ku.eval.wait_expr);
00674 
00675   gcMARK(pr->ku.apply.tail_rator);
00676   gcMARK(pr->ku.apply.tail_rands);
00677 
00678   gcMARK(pr->ku.multiple.array);
00679 
00680   gcMARK(pr->ku.k.p1);
00681   gcMARK(pr->ku.k.p2);
00682   gcMARK(pr->ku.k.p3);
00683   gcMARK(pr->ku.k.p4);
00684   gcMARK(pr->ku.k.p5);
00685   
00686   gcMARK(pr->list_stack);
00687   
00688   gcMARK(pr->kill_data);
00689   gcMARK(pr->private_kill_data);
00690   gcMARK(pr->private_kill_next);
00691   
00692   gcMARK(pr->user_tls);
00693   gcMARK(pr->gmp_tls_data);
00694   
00695   gcMARK(pr->mr_hop);
00696   gcMARK(pr->mref);
00697   gcMARK(pr->extra_mrefs);
00698 
00699   gcMARK(pr->name);
00700 
00701   gcMARK(pr->transitive_resumes);
00702 
00703   gcMARK(pr->suspended_box);
00704   gcMARK(pr->resumed_box);
00705   gcMARK(pr->dead_box);
00706   gcMARK(pr->running_box);
00707 
00708   gcMARK(pr->mbox_first);
00709   gcMARK(pr->mbox_last);
00710   gcMARK(pr->mbox_sema);
00711  size:
00712   gcBYTES_TO_WORDS(sizeof(Scheme_Thread));
00713 }
00714 
00715 runstack_val {
00716   long *s = (long *)p;
00717  mark:
00718   void **a, **b;
00719   a = (void **)s + 4 + s[2];
00720   b = (void **)s + 4 + s[3];
00721   while (a < b) {
00722     gcMARK(*a);
00723     a++;
00724   }
00725  more:
00726  fixup:
00727   /* Zero out the part that we didn't mark, in case it becomes
00728      live later. */
00729   a = (void **)s + 4;
00730   b = (void **)s + 4 + s[2];
00731   while (a < b) {
00732     *a = RUNSTACK_ZERO_VAL;
00733     a++;
00734   }
00735   a = (void **)s + 4 + s[3];
00736   b = (void **)s + 4 + (s[1] - 4);
00737   while (a < b) {
00738     *a = RUNSTACK_ZERO_VAL;
00739     a++;
00740   }
00741  size:
00742   s[1];
00743 }
00744 
00745 prompt_val {
00746  mark: 
00747   Scheme_Prompt *pr = (Scheme_Prompt *)p;
00748   gcMARK(pr->boundary_overflow_id);
00749   if (!GC_merely_accounting())
00750     gcMARK(pr->runstack_boundary_start);
00751   gcMARK(pr->tag);
00752   gcMARK(pr->id);
00753  size:
00754   gcBYTES_TO_WORDS(sizeof(Scheme_Prompt));
00755 }
00756 
00757 cont_mark_set_val {
00758  mark:
00759   Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p;
00760   gcMARK(s->chain);
00761   gcMARK(s->native_stack_trace);
00762 
00763  size:
00764   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set));
00765 }
00766 
00767 sema_val {
00768  mark:
00769   Scheme_Sema *s = (Scheme_Sema *)p;
00770 
00771   gcMARK(s->first);
00772   gcMARK(s->last);
00773 
00774  size:
00775   gcBYTES_TO_WORDS(sizeof(Scheme_Sema));
00776 }
00777 
00778 channel_val {
00779  mark:
00780   Scheme_Channel *s = (Scheme_Channel *)p;
00781 
00782   gcMARK(s->get_first);
00783   gcMARK(s->get_last);
00784   gcMARK(s->put_first);
00785   gcMARK(s->put_last);
00786 
00787  size:
00788   gcBYTES_TO_WORDS(sizeof(Scheme_Channel));
00789 }
00790 
00791 channel_put_val {
00792  mark:
00793   Scheme_Channel_Put *s = (Scheme_Channel_Put *)p;
00794 
00795   gcMARK(s->ch);
00796   gcMARK(s->val);
00797 
00798  size:
00799   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put));
00800 }
00801 
00802 hash_table_val {
00803  mark:
00804   Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p;
00805 
00806   gcMARK(ht->keys);
00807   gcMARK(ht->vals);
00808   gcMARK(ht->mutex);
00809 
00810  size:
00811   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table));
00812 }
00813 
00814 bucket_table_val {
00815  mark:
00816   Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p;
00817 
00818   gcMARK(ht->buckets);
00819   gcMARK(ht->mutex);
00820 
00821  size:
00822   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table));
00823 }
00824 
00825 namespace_val {
00826  mark:
00827   Scheme_Env *e = (Scheme_Env *)p;
00828 
00829   gcMARK(e->module);
00830   gcMARK(e->module_registry);
00831   gcMARK(e->export_registry);
00832   gcMARK(e->insp);
00833 
00834   gcMARK(e->rename_set);
00835   gcMARK(e->temp_marked_names);
00836   gcMARK(e->post_ex_rename_set);
00837 
00838   gcMARK(e->syntax);
00839   gcMARK(e->exp_env);
00840   gcMARK(e->template_env);
00841   gcMARK(e->label_env);
00842 
00843   gcMARK(e->shadowed_syntax);
00844 
00845   gcMARK(e->link_midx);
00846   gcMARK(e->require_names);
00847   gcMARK(e->et_require_names);
00848   gcMARK(e->tt_require_names);
00849   gcMARK(e->dt_require_names);
00850   gcMARK(e->other_require_names);
00851   gcMARK(e->did_starts);
00852   gcMARK(e->available_next[0]);
00853   gcMARK(e->available_next[1]);
00854 
00855   gcMARK(e->toplevel);
00856   gcMARK(e->modchain);
00857 
00858   gcMARK(e->modvars);
00859 
00860 
00861  size:
00862   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
00863 }
00864 
00865 random_state_val {
00866  mark:
00867  size:
00868   gcBYTES_TO_WORDS(sizeof(Scheme_Random_State));
00869 }
00870 
00871 compilation_top_val {
00872  mark:
00873   Scheme_Compilation_Top *t = (Scheme_Compilation_Top *)p;
00874   gcMARK(t->code);
00875   gcMARK(t->prefix);
00876 
00877  size:
00878   gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top));
00879 }
00880 
00881 resolve_prefix_val {
00882  mark:
00883   Resolve_Prefix *rp = (Resolve_Prefix *)p;
00884   gcMARK(rp->toplevels);
00885   gcMARK(rp->stxes);
00886   gcMARK(rp->delay_info_rpair);
00887 
00888  size:
00889   gcBYTES_TO_WORDS(sizeof(Resolve_Prefix));
00890 }
00891 
00892 comp_prefix_val {
00893  mark:
00894   Comp_Prefix *cp = (Comp_Prefix *)p;
00895   gcMARK(cp->toplevels);
00896   gcMARK(cp->stxes);
00897 
00898  size:
00899   gcBYTES_TO_WORDS(sizeof(Comp_Prefix));
00900 }
00901 
00902 svector_val {
00903  mark:
00904   Scheme_Object *o = (Scheme_Object *)p;
00905 
00906   gcMARK(SCHEME_SVEC_VEC(o));
00907 
00908  size:
00909   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00910 }
00911 
00912 stx_val {
00913  mark:
00914   Scheme_Stx *stx = (Scheme_Stx *)p;
00915   gcMARK(stx->val);
00916   gcMARK(stx->srcloc);
00917   gcMARK(stx->wraps);
00918   gcMARK(stx->certs);
00919   gcMARK(stx->props);
00920   if (!(MZ_OPT_HASH_KEY(&(stx)->iso) & STX_SUBSTX_FLAG))
00921     gcMARK(stx->u.modinfo_cache);
00922  size:
00923   gcBYTES_TO_WORDS(sizeof(Scheme_Stx));
00924 }
00925 
00926 stx_off_val {
00927  mark:
00928   Scheme_Stx_Offset *o = (Scheme_Stx_Offset *)p;
00929   gcMARK(o->src);
00930  size:
00931   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset));
00932 }
00933 
00934 module_val {
00935  mark:
00936   Scheme_Module *m = (Scheme_Module *)p;
00937   gcMARK(m->modname);
00938 
00939   gcMARK(m->et_requires);
00940   gcMARK(m->requires);
00941   gcMARK(m->tt_requires);
00942   gcMARK(m->dt_requires);
00943   gcMARK(m->other_requires);
00944 
00945   gcMARK(m->body);
00946   gcMARK(m->et_body);
00947 
00948   gcMARK(m->me);
00949 
00950   gcMARK(m->provide_protects);
00951   gcMARK(m->indirect_provides);
00952 
00953   gcMARK(m->indirect_syntax_provides);
00954 
00955   gcMARK(m->et_provide_protects);
00956   gcMARK(m->et_indirect_provides);
00957 
00958   gcMARK(m->self_modidx);
00959 
00960   gcMARK(m->accessible);
00961   gcMARK(m->et_accessible);
00962 
00963   gcMARK(m->insp);
00964 
00965   gcMARK(m->lang_info);
00966 
00967   gcMARK(m->hints);
00968   gcMARK(m->ii_src);
00969 
00970   gcMARK(m->comp_prefix);
00971   gcMARK(m->prefix);
00972   gcMARK(m->dummy);
00973 
00974   gcMARK(m->rn_stx);
00975 
00976   gcMARK(m->primitive);
00977  size:
00978   gcBYTES_TO_WORDS(sizeof(Scheme_Module));
00979 }
00980 
00981 module_phase_exports_val {
00982  mark:
00983   Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p;
00984 
00985   gcMARK(m->phase_index);
00986 
00987   gcMARK(m->src_modidx);
00988 
00989   gcMARK(m->provides);
00990   gcMARK(m->provide_srcs);
00991   gcMARK(m->provide_src_names);
00992   gcMARK(m->provide_nominal_srcs);
00993   gcMARK(m->provide_src_phases);
00994   gcMARK(m->provide_insps);
00995 
00996   gcMARK(m->kernel_exclusion);
00997   gcMARK(m->kernel_exclusion2);
00998 
00999   gcMARK(m->ht);
01000 
01001  size:
01002   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports));
01003 }
01004 
01005 module_exports_val {
01006  mark:
01007   Scheme_Module_Exports *m = (Scheme_Module_Exports *)p;
01008 
01009   gcMARK(m->rt);
01010   gcMARK(m->et);
01011   gcMARK(m->dt);
01012   gcMARK(m->other_phases);
01013 
01014   gcMARK(m->src_modidx);
01015  size:
01016   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports));
01017 }
01018 
01019 modidx_val {
01020  mark:
01021   Scheme_Modidx *modidx = (Scheme_Modidx *)p;
01022 
01023   gcMARK(modidx->path);
01024   gcMARK(modidx->base);
01025   gcMARK(modidx->resolved);
01026   gcMARK(modidx->shift_cache);
01027   gcMARK(modidx->cache_next);
01028  size:
01029   gcBYTES_TO_WORDS(sizeof(Scheme_Modidx));
01030 }
01031 
01032 guard_val {
01033  mark:
01034   Scheme_Security_Guard *g = (Scheme_Security_Guard *)p;
01035 
01036   gcMARK(g->parent);
01037   gcMARK(g->file_proc);
01038   gcMARK(g->network_proc);
01039   gcMARK(g->link_proc);
01040  size:
01041   gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard));
01042 }
01043 
01044 buf_holder {
01045  mark:
01046   Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p;
01047  
01048   MARK_jmpup(&h->buf);
01049 
01050  size:
01051   gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder));
01052 }
01053 
01054 mark_inspector {
01055  mark:
01056   Scheme_Inspector *i = (Scheme_Inspector *)p;
01057   gcMARK(i->superior);
01058  size:
01059   gcBYTES_TO_WORDS(sizeof(Scheme_Inspector));
01060 }
01061 
01062 mark_pipe {
01063  mark:
01064   Scheme_Pipe *pp = (Scheme_Pipe *)p;
01065     
01066   gcMARK(pp->buf);
01067   gcMARK(pp->wakeup_on_read);
01068   gcMARK(pp->wakeup_on_write);
01069 
01070  size:
01071   gcBYTES_TO_WORDS(sizeof(Scheme_Pipe));
01072 }
01073 
01074 mark_logger {
01075  mark:
01076   Scheme_Logger *l = (Scheme_Logger *)p;
01077   gcMARK(l->name);
01078   gcMARK(l->parent);
01079   gcMARK(l->readers);
01080   gcMARK(l->timestamp);
01081  size:
01082   gcBYTES_TO_WORDS(sizeof(Scheme_Logger));
01083 }
01084 
01085 mark_log_reader {
01086  mark:
01087   Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p;
01088   gcMARK(lr->sema);
01089   gcMARK(lr->head);
01090   gcMARK(lr->tail);
01091  size:
01092   gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader));
01093 }
01094 
01095 END type;
01096 
01097 /**********************************************************************/
01098 
01099 START engine;
01100 
01101 engine_val {
01102  mark:
01103   Scheme_Engine *en = (Scheme_Engine *)p;
01104  size:
01105   gcBYTES_TO_WORDS(sizeof(Scheme_Engine));
01106 }
01107 
01108 END engine;
01109 
01110 START env;
01111 
01112 mark_comp_env {
01113  mark:
01114   Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p;
01115 
01116   gcMARK(e->base.genv);
01117   gcMARK(e->base.insp);
01118   gcMARK(e->base.prefix);
01119   gcMARK(e->base.next);
01120   gcMARK(e->base.values);
01121   gcMARK(e->base.certs);
01122   gcMARK(e->base.renames);
01123   gcMARK(e->base.uid);
01124   gcMARK(e->base.uids);
01125   gcMARK(e->base.dup_check);
01126   gcMARK(e->base.intdef_name);
01127   gcMARK(e->base.in_modidx);
01128   gcMARK(e->base.skip_table);
01129   
01130   gcMARK(e->data.const_names);
01131   gcMARK(e->data.const_vals);
01132   gcMARK(e->data.const_uids);
01133   gcMARK(e->data.sealed);
01134   gcMARK(e->data.use);
01135   gcMARK(e->data.lifts);
01136 
01137  size:
01138   gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
01139 }
01140 
01141 mark_resolve_info {
01142  mark:
01143   Resolve_Info *i = (Resolve_Info *)p;
01144   
01145   gcMARK(i->prefix);
01146   gcMARK(i->stx_map);
01147   gcMARK(i->old_pos);
01148   gcMARK(i->new_pos);
01149   gcMARK(i->old_stx_pos);
01150   gcMARK(i->flags);
01151   gcMARK(i->lifts);
01152   gcMARK(i->lifted);
01153   gcMARK(i->next);
01154 
01155  size:
01156   gcBYTES_TO_WORDS(sizeof(Resolve_Info));
01157 }
01158 
01159 mark_optimize_info {
01160  mark:
01161   Optimize_Info *i = (Optimize_Info *)p;
01162   
01163   gcMARK(i->stat_dists);
01164   gcMARK(i->sd_depths);
01165   gcMARK(i->next);
01166   gcMARK(i->use);
01167   gcMARK(i->consts);
01168   gcMARK(i->top_level_consts);
01169   gcMARK(i->transitive_use);
01170   gcMARK(i->transitive_use_len);
01171   gcMARK(i->context);
01172 
01173  size:
01174   gcBYTES_TO_WORDS(sizeof(Optimize_Info));
01175 }
01176 
01177 mark_sfs_info {
01178  mark:
01179   SFS_Info *i = (SFS_Info *)p;
01180   
01181   gcMARK(i->max_used);
01182   gcMARK(i->max_calls);
01183   gcMARK(i->saved);
01184 
01185  size:
01186   gcBYTES_TO_WORDS(sizeof(SFS_Info));
01187 }
01188 
01189 END env;
01190 
01191 /**********************************************************************/
01192 
01193 START eval;
01194 
01195 mark_comp_info {
01196  mark:
01197   Scheme_Compile_Info *i = (Scheme_Compile_Info *)p;
01198   
01199   gcMARK(i->value_name);
01200   gcMARK(i->certs);
01201   gcMARK(i->observer);
01202 
01203  size:
01204   gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
01205 }
01206 
01207 mark_saved_stack {
01208  mark:
01209   Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
01210   
01211   gcMARK(saved->prev);
01212   gcMARK(saved->runstack_start);
01213 
01214  size:
01215   gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
01216 }
01217 
01218 mark_validate_clearing {
01219  mark:
01220   Validate_Clearing *vc = (Validate_Clearing *)p;
01221   
01222   gcMARK(vc->stack);
01223   gcMARK(vc->ncstack);
01224 
01225  size:
01226   gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
01227 }
01228 
01229 END eval;
01230 
01231 /**********************************************************************/
01232 
01233 START file;
01234 
01235 mark_reply_item {
01236  mark:
01237   ReplyItem *r = (ReplyItem *)p;
01238   
01239   gcMARK(r->next);
01240 
01241  size:
01242   gcBYTES_TO_WORDS(sizeof(ReplyItem));
01243 }
01244 
01245 END file;
01246 
01247 /**********************************************************************/
01248 
01249 START fun;
01250 
01251 mark_closure_info {
01252  mark:
01253   Closure_Info *i = (Closure_Info *)p;
01254   
01255   gcMARK(i->local_flags);
01256   gcMARK(i->base_closure_map);
01257 
01258  size:
01259   gcBYTES_TO_WORDS(sizeof(Closure_Info));
01260 }
01261 
01262 mark_dyn_wind_cell {
01263  mark:
01264   Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
01265   
01266   gcMARK(l->dw);
01267   gcMARK(l->next);
01268   
01269  size:
01270   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
01271 }
01272 
01273 mark_dyn_wind_info {
01274  mark:
01275   Dyn_Wind *d = (Dyn_Wind *)p;
01276   
01277   gcMARK(d->pre);
01278   gcMARK(d->act);
01279   gcMARK(d->post);
01280 
01281  size:
01282    gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
01283 }
01284 
01285 mark_cont_mark_chain {
01286  mark:
01287   Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
01288   
01289   gcMARK(c->key);
01290   gcMARK(c->val);
01291   gcMARK(c->next);
01292 
01293  size:
01294   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
01295 }
01296 
01297 END fun;
01298 
01299 /**********************************************************************/
01300 
01301 START hash;
01302 
01303 hash_tree_val {
01304  mark:
01305   Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
01306 
01307   gcMARK(ht->root);
01308   gcMARK(ht->elems_box);
01309 
01310  size:
01311   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
01312 }
01313 
01314 mark_rb_node {
01315  mark:
01316   RBNode *rb = (RBNode *)p;
01317 
01318   /* Short-circuit on NULL pointers, which are especially likely */
01319   if (rb->left) {
01320     gcMARK(rb->left);
01321   }
01322   if (rb->right) {
01323     gcMARK(rb->right);
01324   }
01325   gcMARK(rb->key);
01326   gcMARK(rb->val);
01327 
01328  size:
01329   gcBYTES_TO_WORDS(sizeof(RBNode));
01330 }
01331 
01332 END hash;
01333 
01334 /**********************************************************************/
01335 
01336 START places;
01337 
01338 place_val {
01339  mark:
01340   Scheme_Place *pr = (Scheme_Place *)p;
01341  size:
01342   gcBYTES_TO_WORDS(sizeof(Scheme_Place));
01343 }
01344 
01345 END places;
01346 
01347 /**********************************************************************/
01348 
01349 START portfun;
01350 
01351 mark_load_handler_data {
01352  mark:
01353   LoadHandlerData *d = (LoadHandlerData *)p;
01354     
01355   gcMARK(d->config);
01356   gcMARK(d->port);
01357   gcMARK(d->p);
01358   gcMARK(d->stxsrc);
01359   gcMARK(d->expected_module);
01360   gcMARK(d->delay_load_info);
01361   
01362  size:
01363   gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
01364 }
01365 
01366 mark_indexed_string {
01367  mark:
01368   Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
01369     
01370   gcMARK(is->string);
01371 
01372  size:
01373   gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
01374 }
01375 
01376 mark_user_input {
01377  mark:
01378   User_Input_Port *uip = (User_Input_Port *)p;
01379 
01380   gcMARK(uip->read_proc);
01381   gcMARK(uip->peek_proc);
01382   gcMARK(uip->progress_evt_proc);
01383   gcMARK(uip->peeked_read_proc);
01384   gcMARK(uip->location_proc);
01385   gcMARK(uip->count_lines_proc);
01386   gcMARK(uip->buffer_mode_proc);
01387   gcMARK(uip->close_proc);
01388   gcMARK(uip->reuse_str);
01389   gcMARK(uip->peeked);
01390   gcMARK(uip->prefix_pipe);
01391  size:
01392   gcBYTES_TO_WORDS(sizeof(User_Input_Port));
01393 }
01394 
01395 mark_user_output {
01396  mark:
01397   User_Output_Port *uop = (User_Output_Port *)p;
01398 
01399   gcMARK(uop->evt);
01400   gcMARK(uop->write_evt_proc);
01401   gcMARK(uop->write_proc);
01402   gcMARK(uop->write_special_evt_proc);
01403   gcMARK(uop->write_special_proc);
01404   gcMARK(uop->location_proc);
01405   gcMARK(uop->count_lines_proc);
01406   gcMARK(uop->buffer_mode_proc);
01407   gcMARK(uop->close_proc);
01408   gcMARK(uop->buffer_pipe);
01409  size:
01410   gcBYTES_TO_WORDS(sizeof(User_Output_Port));
01411 }
01412 
01413 END portfun;
01414 
01415 /**********************************************************************/
01416 
01417 START port;
01418 
01419 #ifdef WINDOWS_PROCESSES
01420 mark_thread_memory {
01421  mark:
01422   Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p;
01423   gcMARK(tm->prev);
01424   gcMARK(tm->next);
01425 
01426  size:
01427   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
01428 }
01429 #endif
01430 
01431 mark_input_file {
01432  mark:
01433   Scheme_Input_File *i = (Scheme_Input_File *)p;
01434 
01435   gcMARK(i->f);
01436 
01437  size:
01438   gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
01439 }
01440 
01441 mark_output_file {
01442  mark:
01443   Scheme_Output_File *o = (Scheme_Output_File *)p;
01444 
01445   gcMARK(o->f);
01446 
01447  size:
01448   gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
01449 }
01450 
01451 #ifdef MZ_FDS
01452 mark_input_fd {
01453  mark:
01454   Scheme_FD *fd = (Scheme_FD *)p;
01455 
01456   gcMARK(fd->buffer);
01457   gcMARK(fd->refcount);
01458 
01459  size:
01460   gcBYTES_TO_WORDS(sizeof(Scheme_FD));
01461 }
01462 #endif
01463 
01464 #if defined(UNIX_PROCESSES)
01465 mark_system_child {
01466  mark:
01467   System_Child *sc = (System_Child *)p;
01468 
01469   gcMARK(sc->next);
01470 
01471  size:
01472   gcBYTES_TO_WORDS(sizeof(System_Child));
01473 }
01474 #endif
01475 
01476 #ifdef USE_OSKIT_CONSOLE
01477 mark_oskit_console_input {
01478  mark:
01479   osk_console_input *c = (osk_console_input *)p;
01480     
01481   gcMARK(c->buffer);
01482   gcMARK(c->next);
01483 
01484  size:
01485   gcBYTES_TO_WORDS(sizeof(osk_console_input));
01486 }
01487 #endif
01488 
01489 mark_subprocess {
01490  mark:
01491 #ifndef WINDOWS_PROCESSES
01492   Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
01493   gcMARK(sp->handle);
01494 #endif
01495  size:
01496   gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
01497 }
01498 
01499 mark_read_write_evt {
01500  mark:
01501   Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
01502   gcMARK(rww->port);
01503   gcMARK(rww->v);
01504   gcMARK(rww->str);
01505  size:
01506   gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
01507 }
01508 
01509 END port;
01510 
01511 /**********************************************************************/
01512 
01513 START print;
01514 
01515 mark_print_params {
01516  mark:
01517   PrintParams *pp = (PrintParams *)p;
01518   gcMARK(pp->inspector);
01519   gcMARK(pp->print_port);
01520   gcMARK(pp->print_buffer);
01521  size:
01522   gcBYTES_TO_WORDS(sizeof(PrintParams));
01523 }
01524 
01525 mark_marshal_tables {
01526  mark:
01527   Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
01528   gcMARK(mt->symtab);
01529   gcMARK(mt->rns);
01530   gcMARK(mt->rn_refs);
01531   gcMARK(mt->st_refs);
01532   gcMARK(mt->st_ref_stack);
01533   gcMARK(mt->reverse_map);
01534   gcMARK(mt->same_map);
01535   gcMARK(mt->cert_lists);
01536   gcMARK(mt->shift_map);
01537   gcMARK(mt->top_map);
01538   gcMARK(mt->key_map);
01539   gcMARK(mt->delay_map);
01540   gcMARK(mt->cdata_map);
01541   gcMARK(mt->rn_saved);
01542   gcMARK(mt->shared_offsets);
01543   gcMARK(mt->sorted_keys);
01544  size:
01545   gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
01546 }
01547 
01548 END print;
01549 
01550 /**********************************************************************/
01551 
01552 START network;
01553 
01554 mark_listener {
01555   listener_t *l = (listener_t *)p;
01556 
01557  mark:
01558 
01559   gcMARK(l->mref);
01560 
01561  size:
01562   gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
01563 }
01564 
01565 #ifdef USE_TCP
01566 mark_tcp {
01567  mark:
01568   Scheme_Tcp *tcp = (Scheme_Tcp *)p;
01569 
01570   gcMARK(tcp->b.buffer);
01571   gcMARK(tcp->b.out_buffer);
01572 
01573  size:
01574   gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
01575 }
01576 
01577 # ifdef UDP_IS_SUPPORTED
01578 mark_udp {
01579  mark:
01580   Scheme_UDP *udp = (Scheme_UDP *)p;
01581 
01582   gcMARK(udp->previous_from_addr);
01583   gcMARK(udp->mref);
01584 
01585  size:
01586   gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
01587 }
01588 
01589 mark_udp_evt {
01590  mark:
01591   Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
01592 
01593   gcMARK(uw->udp);
01594   gcMARK(uw->str);
01595   gcMARK(uw->dest_addr);
01596 
01597  size:
01598   gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
01599 }
01600 # endif
01601 #endif
01602 
01603 END network;
01604 
01605 /**********************************************************************/
01606 
01607 START thread;
01608 
01609 mark_parameterization {
01610  mark:
01611   Scheme_Parameterization *c = (Scheme_Parameterization *)p;
01612   int i;
01613     
01614   for (i = max_configs; i--; ) {
01615     gcMARK(c->prims[i]);
01616   }
01617   gcMARK(c->extensions);
01618 
01619  size:
01620   gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
01621                   + ((max_configs - 1) * sizeof(Scheme_Object*))));
01622 }
01623 
01624 mark_config {
01625  mark:
01626   Scheme_Config *config = (Scheme_Config *)p;
01627   gcMARK(config->key);
01628   gcMARK(config->cell);
01629   gcMARK(config->next);
01630  size:
01631   gcBYTES_TO_WORDS(sizeof(Scheme_Config));
01632 }
01633 
01634 mark_will_executor_val {
01635  mark:
01636   WillExecutor *e = (WillExecutor *)p;
01637   
01638   gcMARK(e->sema);
01639   gcMARK(e->first);
01640   gcMARK(e->last);
01641 
01642  size:
01643   gcBYTES_TO_WORDS(sizeof(WillExecutor));
01644 }
01645 
01646 mark_custodian_val {
01647  mark:
01648   Scheme_Custodian *m = (Scheme_Custodian *)p;
01649   
01650   gcMARK(m->boxes);
01651   gcMARK(m->mrefs);
01652   gcMARK(m->closers);
01653   gcMARK(m->data);
01654 
01655   gcMARK(m->parent);
01656   gcMARK(m->sibling);
01657   gcMARK(m->children);
01658 
01659   gcMARK(m->global_next);
01660   gcMARK(m->global_prev);
01661 
01662   gcMARK(m->cust_boxes);
01663 
01664  size:
01665   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
01666 }
01667 
01668 mark_custodian_box_val {
01669  mark:
01670   Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
01671   int sd = ((Scheme_Custodian *)GC_resolve(b->cust))->shut_down;
01672 
01673   gcMARK(b->cust);
01674   if (!sd) {
01675     gcMARK(b->v);
01676   }
01677 
01678  size:
01679   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
01680 }
01681 
01682 mark_thread_hop {
01683  mark:
01684   Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
01685 
01686   gcMARK(hop->p);
01687 
01688  size:
01689    gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
01690 }
01691 
01692 mark_namespace_option {
01693  mark:
01694   Scheme_NSO *o = (Scheme_NSO *)p;
01695 
01696   gcMARK(o->key);
01697 
01698  size:
01699   gcBYTES_TO_WORDS(sizeof(Scheme_NSO));
01700 }
01701 
01702 mark_param_data {
01703  mark:
01704   ParamData *d = (ParamData *)p;
01705 
01706   gcMARK(d->key);
01707   gcMARK(d->guard);
01708   gcMARK(d->extract_guard);
01709   gcMARK(d->defcell);
01710 
01711  size:
01712    gcBYTES_TO_WORDS(sizeof(ParamData));
01713 }
01714 
01715 mark_will {
01716  mark:
01717   ActiveWill *w = (ActiveWill *)p;
01718   
01719   gcMARK(w->o);
01720   gcMARK(w->proc);
01721   gcMARK(w->w);
01722   gcMARK(w->next);
01723 
01724  size:
01725   gcBYTES_TO_WORDS(sizeof(ActiveWill));
01726 }
01727 
01728 mark_evt {
01729  mark:
01730  size:
01731   gcBYTES_TO_WORDS(sizeof(Evt));
01732 }
01733 
01734 mark_syncing {
01735  mark:
01736   Syncing *w = (Syncing *)p;
01737  
01738   gcMARK(w->set);
01739   gcMARK(w->wrapss);
01740   gcMARK(w->nackss);
01741   gcMARK(w->reposts);
01742   gcMARK(w->accepts);
01743   gcMARK(w->disable_break);
01744 
01745  size:
01746   gcBYTES_TO_WORDS(sizeof(Syncing));
01747 }
01748 
01749 mark_evt_set {
01750  mark:
01751   Evt_Set *w = (Evt_Set *)p;
01752  
01753   gcMARK(w->ws);
01754   gcMARK(w->argv);
01755 
01756  size:
01757   gcBYTES_TO_WORDS(sizeof(Evt_Set));
01758 }
01759 
01760 mark_thread_set {
01761  mark:
01762   Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
01763  
01764   gcMARK(ts->parent);
01765   gcMARK(ts->first);
01766   gcMARK(ts->next);
01767   gcMARK(ts->prev);
01768   gcMARK(ts->search_start);
01769   gcMARK(ts->current);
01770 
01771  size:
01772   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
01773 }
01774 
01775 mark_thread_cell {
01776  mark:
01777   Thread_Cell *c = (Thread_Cell *)p;
01778  
01779   gcMARK(c->def_val);
01780 
01781  size:
01782   gcBYTES_TO_WORDS(sizeof(Thread_Cell));
01783 }
01784 
01785 END thread;
01786 
01787 /**********************************************************************/
01788 
01789 START salloc;
01790 
01791 mark_finalization {
01792  mark:
01793   Finalization *f = (Finalization *)p;
01794   
01795   gcMARK(f->data);
01796   gcMARK(f->next);
01797   gcMARK(f->prev);
01798 
01799  size:
01800   gcBYTES_TO_WORDS(sizeof(Finalization));
01801 }
01802 
01803 mark_finalizations {
01804  mark:
01805   Finalizations *f = (Finalizations *)p;
01806 
01807   gcMARK(f->scheme_first);
01808   gcMARK(f->scheme_last);
01809   gcMARK(f->prim_first);
01810   gcMARK(f->prim_last);
01811   gcMARK(f->ext_data);
01812 
01813  size:
01814   gcBYTES_TO_WORDS(sizeof(Finalizations));
01815 }
01816 
01817 END salloc;
01818 
01819 /**********************************************************************/
01820 
01821 START sema;
01822 
01823 mark_channel_syncer {
01824  mark:
01825   Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
01826 
01827   gcMARK(w->p);
01828   gcMARK(w->prev);
01829   gcMARK(w->next);
01830   gcMARK(w->syncing);
01831   gcMARK(w->obj);
01832 
01833  size:
01834   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
01835 }
01836 
01837 mark_alarm {
01838  mark:
01839  size:
01840   gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
01841 }
01842 
01843 END sema;
01844 
01845 /**********************************************************************/
01846 
01847 START struct;
01848 
01849 mark_struct_val {
01850   Scheme_Structure *s = (Scheme_Structure *)p;
01851   int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots;
01852 
01853  mark:
01854   int i;
01855 
01856   gcFIXUP_TYPED_NOW(Scheme_Struct_Type *, s->stype);
01857   
01858   for(i = num_slots; i--; )
01859     gcMARK(s->slots[i]);
01860 
01861  size:
01862   gcBYTES_TO_WORDS((sizeof(Scheme_Structure) 
01863                   + ((num_slots - 1) * sizeof(Scheme_Object *))));
01864 }
01865 
01866 mark_struct_type_val {
01867   Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
01868 
01869  mark:
01870   int i;
01871   for (i = t->name_pos + 1; i--; ) {
01872     gcMARK(t->parent_types[i]);
01873   }
01874   gcMARK(t->name);
01875   gcMARK(t->inspector);
01876   gcMARK(t->accessor);
01877   gcMARK(t->mutator);
01878   gcMARK(t->prefab_key);
01879   gcMARK(t->uninit_val);
01880   gcMARK(t->props);
01881   gcMARK(t->proc_attr);
01882   gcMARK(t->guard);
01883   gcMARK(t->immutables);
01884 
01885  size:
01886   gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
01887                   + (t->name_pos * sizeof(Scheme_Struct_Type *))));
01888 }
01889 
01890 mark_struct_proc_info {
01891  mark:
01892   Struct_Proc_Info *i = (Struct_Proc_Info *)p;
01893 
01894   gcMARK(i->struct_type);
01895   gcMARK(i->func_name);
01896 
01897  size:
01898   gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
01899 }
01900 
01901 mark_struct_property {
01902  mark:
01903   Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
01904   gcMARK(i->name);
01905   gcMARK(i->guard);
01906   gcMARK(i->supers);
01907  size:
01908   gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
01909 }
01910 
01911 mark_wrapped_evt {
01912  mark:
01913   Wrapped_Evt *ww = (Wrapped_Evt *)p;
01914 
01915   gcMARK(ww->evt);
01916   gcMARK(ww->wrapper);
01917 
01918  size:
01919   gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
01920 }
01921 
01922 mark_nack_guard_evt {
01923  mark:
01924   Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
01925 
01926   gcMARK(nw->maker);
01927 
01928  size:
01929   gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
01930 }
01931 
01932 END struct;
01933 
01934 /**********************************************************************/
01935 
01936 START syntax;
01937 
01938 END syntax;
01939 
01940 /**********************************************************************/
01941 
01942 START read;
01943 
01944 mark_indent {
01945  mark:
01946  size:
01947   gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
01948 }
01949 
01950 mark_cport {
01951  mark:
01952   CPort *cp = (CPort *)p;
01953   gcMARK(cp->start);
01954   gcMARK(cp->orig_port);
01955   gcMARK(cp->ht);
01956   gcMARK(cp->ut);
01957   gcMARK(cp->symtab);
01958   gcMARK(cp->insp);
01959   gcMARK(cp->relto);
01960   gcMARK(cp->magic_sym);
01961   gcMARK(cp->magic_val);
01962   gcMARK(cp->shared_offsets);
01963   gcMARK(cp->delay_info);
01964  size:
01965   gcBYTES_TO_WORDS(sizeof(CPort));
01966 }
01967 
01968 mark_readtable {
01969  mark:
01970   Readtable *t = (Readtable *)p;
01971   gcMARK(t->mapping);
01972   gcMARK(t->fast_mapping);
01973   gcMARK(t->symbol_parser);
01974   gcMARK(t->names);
01975  size:
01976   gcBYTES_TO_WORDS(sizeof(Readtable));
01977 }
01978 
01979 mark_read_params {
01980  mark:
01981   ReadParams *rp = (ReadParams *)p;
01982   gcMARK(rp->table);
01983   gcMARK(rp->magic_sym);
01984   gcMARK(rp->magic_val);
01985   gcMARK(rp->delay_load_info);
01986  size:
01987   gcBYTES_TO_WORDS(sizeof(ReadParams));
01988 }
01989 
01990 mark_delay_load {
01991  mark:
01992   Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
01993   gcMARK(ld->path);
01994   gcMARK(ld->symtab);
01995   gcMARK(ld->shared_offsets);
01996   gcMARK(ld->insp);
01997   gcMARK(ld->relto);
01998   gcMARK(ld->ut);
01999   gcMARK(ld->current_rp);
02000   gcMARK(ld->cached);
02001   gcMARK(ld->cached_port);
02002  size:
02003   gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
02004 }
02005 
02006 mark_unmarshal_tables {
02007  mark:
02008   Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
02009   gcMARK(ut->rns);
02010   gcMARK(ut->rp);
02011   gcMARK(ut->decoded);
02012  size:
02013   gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
02014 }
02015 
02016 END read;
02017 
02018 /**********************************************************************/
02019 
02020 START regexp;
02021 
02022 mark_regexp {
02023   regexp *r = (regexp *)p;
02024  mark:
02025   gcMARK(r->source);
02026   gcMARK(r->regstart);
02027  size:
02028   gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
02029 }
02030 
02031 mark_regwork {
02032  mark:
02033   Regwork *r = (Regwork *)p;
02034   gcMARK(r->str);
02035   gcMARK(r->instr);
02036   gcMARK(r->port);
02037   gcMARK(r->unless_evt);
02038   gcMARK(r->startp);
02039   gcMARK(r->maybep);
02040   gcMARK(r->endp);
02041   gcMARK(r->counters);
02042   gcMARK(r->peekskip);
02043  size:
02044   gcBYTES_TO_WORDS(sizeof(Regwork));
02045 }
02046 
02047 END regexp;
02048 
02049 /**********************************************************************/
02050 
02051 START string;
02052 
02053 mark_string_convert {
02054  mark:
02055   Scheme_Converter *c = (Scheme_Converter *)p;
02056   gcMARK(c->mref);
02057  size:
02058   gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
02059 }
02060 
02061 END string;
02062 
02063 /**********************************************************************/
02064 
02065 START stxobj;
02066 
02067 mark_rename_table {
02068  mark:
02069   Module_Renames *rn = (Module_Renames *)p;
02070   gcMARK(rn->phase);
02071   gcMARK(rn->ht);
02072   gcMARK(rn->nomarshal_ht);
02073   gcMARK(rn->unmarshal_info);
02074   gcMARK(rn->shared_pes);
02075   gcMARK(rn->set_identity);
02076   gcMARK(rn->marked_names);
02077   gcMARK(rn->free_id_renames);
02078  size:
02079   gcBYTES_TO_WORDS(sizeof(Module_Renames));
02080 }
02081 
02082 mark_rename_table_set {
02083  mark:
02084   Module_Renames_Set *rns = (Module_Renames_Set *)p;
02085   gcMARK(rns->et);
02086   gcMARK(rns->rt);
02087   gcMARK(rns->other_phases);
02088   gcMARK(rns->share_marked_names);
02089   gcMARK(rns->set_identity);
02090  size:
02091   gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
02092 }
02093 
02094 mark_srcloc {
02095  mark:
02096   Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
02097   gcMARK(s->src);
02098  size:
02099   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
02100 }
02101 
02102 mark_wrapchunk {
02103   Wrap_Chunk *wc = (Wrap_Chunk *)p;
02104  mark:
02105   int i;
02106   for (i = wc->len; i--; ) {
02107     gcMARK(wc->a[i]);
02108   }
02109  size:
02110   gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
02111 }
02112 
02113 mark_cert {
02114  mark:
02115   Scheme_Cert *c = (Scheme_Cert *)p;
02116   gcMARK(c->mark);
02117   gcMARK(c->modidx);
02118   gcMARK(c->insp);
02119   gcMARK(c->key);
02120   gcMARK(c->mapped);
02121   gcMARK(c->next);
02122  size:
02123   gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
02124 }
02125 
02126 lex_rib {
02127  mark:
02128   Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p;
02129   gcMARK(rib->rename);
02130   gcMARK(rib->timestamp);
02131   gcMARK(rib->sealed);
02132   gcMARK(rib->next);
02133  size:
02134   gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
02135 }
02136 
02137 mark_free_id_info {
02138  mark:
02139   Scheme_Vector *vec = (Scheme_Vector *)p;
02140   int i;
02141   for (i = 8; i--; )
02142     gcMARK(vec->els[i]);
02143 
02144  size:
02145   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
02146                   + ((8 - 1) * sizeof(Scheme_Object *))));
02147 }
02148 
02149 
02150 
02151 END stxobj;
02152 
02153 /**********************************************************************/
02154 
02155 START jit;
02156 
02157 native_closure {
02158   Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
02159   int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size;
02160 
02161   if (closure_size < 0) {
02162     closure_size = -(closure_size + 1);
02163   }
02164 
02165  mark:
02166 
02167   {
02168     int i = closure_size;
02169     while (i--)
02170       gcMARK(c->vals[i]);
02171   }
02172   gcMARK(c->code);
02173   
02174  size:
02175   gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
02176                   + (closure_size - 1) * sizeof(Scheme_Object *)));
02177 }
02178 
02179 mark_jit_state {
02180  mark:
02181   mz_jit_state *j = (mz_jit_state *)p;
02182   gcMARK(j->mappings);
02183   gcMARK(j->self_data);
02184  size:
02185   gcBYTES_TO_WORDS(sizeof(mz_jit_state));
02186 }
02187 
02188 native_unclosed_proc {
02189  mark:
02190   Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
02191   int i;
02192 
02193   gcMARK(d->u2.name);
02194   if (d->retained) {
02195     for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) {
02196       gcMARK(d->retained[i]);
02197     }
02198   }
02199   if (d->closure_size < 0) {
02200     gcMARK(d->u.arities);
02201   }
02202 
02203  size:
02204   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
02205 }
02206 
02207 native_unclosed_proc_plus_case {
02208  mark:
02209   Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p;
02210 
02211   native_unclosed_proc_MARK(p);
02212   gcMARK(d->case_lam);
02213 
02214  size:
02215   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
02216 }
02217 
02218 END jit;
02219 
02220 /**********************************************************************/
02221 
02222 #define GC_REG_TRAV(type, base) GC_register_traversers(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC)