Back to index

plt-scheme  4.2.1
mzmark.c
Go to the documentation of this file.
00001 /* >>>> Generated by mkmark.ss from mzmarksrc.c <<<< */
00002 
00003 #ifdef MARKS_FOR_TYPE_C
00004 
00005 static int variable_obj_SIZE(void *p) {
00006   return
00007   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home));
00008 }
00009 
00010 static int variable_obj_MARK(void *p) {
00011   Scheme_Bucket *b = (Scheme_Bucket *)p;
00012 
00013   gcMARK(b->key);
00014   gcMARK(b->val);
00015   gcMARK(((Scheme_Bucket_With_Home *)b)->home);
00016 
00017   return
00018   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home));
00019 }
00020 
00021 static int variable_obj_FIXUP(void *p) {
00022   Scheme_Bucket *b = (Scheme_Bucket *)p;
00023 
00024   gcFIXUP(b->key);
00025   gcFIXUP(b->val);
00026   gcFIXUP(((Scheme_Bucket_With_Home *)b)->home);
00027 
00028   return
00029   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home));
00030 }
00031 
00032 #define variable_obj_IS_ATOMIC 0
00033 #define variable_obj_IS_CONST_SIZE 1
00034 
00035 
00036 static int module_var_SIZE(void *p) {
00037   return
00038   gcBYTES_TO_WORDS(sizeof(Module_Variable));
00039 }
00040 
00041 static int module_var_MARK(void *p) {
00042   Module_Variable *mv = (Module_Variable *)p;
00043 
00044   gcMARK(mv->modidx);
00045   gcMARK(mv->sym);
00046   gcMARK(mv->insp);
00047 
00048   return
00049   gcBYTES_TO_WORDS(sizeof(Module_Variable));
00050 }
00051 
00052 static int module_var_FIXUP(void *p) {
00053   Module_Variable *mv = (Module_Variable *)p;
00054 
00055   gcFIXUP(mv->modidx);
00056   gcFIXUP(mv->sym);
00057   gcFIXUP(mv->insp);
00058 
00059   return
00060   gcBYTES_TO_WORDS(sizeof(Module_Variable));
00061 }
00062 
00063 #define module_var_IS_ATOMIC 0
00064 #define module_var_IS_CONST_SIZE 1
00065 
00066 
00067 static int bucket_obj_SIZE(void *p) {
00068   return
00069   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket));
00070 }
00071 
00072 static int bucket_obj_MARK(void *p) {
00073   Scheme_Bucket *b = (Scheme_Bucket *)p;
00074 
00075   gcMARK(b->key);
00076   gcMARK(b->val);
00077 
00078   return
00079   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket));
00080 }
00081 
00082 static int bucket_obj_FIXUP(void *p) {
00083   Scheme_Bucket *b = (Scheme_Bucket *)p;
00084 
00085   gcFIXUP(b->key);
00086   gcFIXUP(b->val);
00087 
00088   return
00089   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket));
00090 }
00091 
00092 #define bucket_obj_IS_ATOMIC 0
00093 #define bucket_obj_IS_CONST_SIZE 1
00094 
00095 
00096 static int local_obj_SIZE(void *p) {
00097   return
00098   gcBYTES_TO_WORDS(sizeof(Scheme_Local));
00099 }
00100 
00101 static int local_obj_MARK(void *p) {
00102   return
00103   gcBYTES_TO_WORDS(sizeof(Scheme_Local));
00104 }
00105 
00106 static int local_obj_FIXUP(void *p) {
00107   return
00108   gcBYTES_TO_WORDS(sizeof(Scheme_Local));
00109 }
00110 
00111 #define local_obj_IS_ATOMIC 1
00112 #define local_obj_IS_CONST_SIZE 1
00113 
00114 
00115 static int toplevel_obj_SIZE(void *p) {
00116   return
00117   gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel));
00118 }
00119 
00120 static int toplevel_obj_MARK(void *p) {
00121   return
00122   gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel));
00123 }
00124 
00125 static int toplevel_obj_FIXUP(void *p) {
00126   return
00127   gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel));
00128 }
00129 
00130 #define toplevel_obj_IS_ATOMIC 1
00131 #define toplevel_obj_IS_CONST_SIZE 1
00132 
00133 
00134 static int quotesyntax_obj_SIZE(void *p) {
00135   return
00136   gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax));
00137 }
00138 
00139 static int quotesyntax_obj_MARK(void *p) {
00140   return
00141   gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax));
00142 }
00143 
00144 static int quotesyntax_obj_FIXUP(void *p) {
00145   return
00146   gcBYTES_TO_WORDS(sizeof(Scheme_Quote_Syntax));
00147 }
00148 
00149 #define quotesyntax_obj_IS_ATOMIC 1
00150 #define quotesyntax_obj_IS_CONST_SIZE 1
00151 
00152 
00153 static int cpointer_obj_SIZE(void *p) {
00154   return
00155   gcBYTES_TO_WORDS(sizeof(Scheme_Cptr));
00156 }
00157 
00158 static int cpointer_obj_MARK(void *p) {
00159   gcMARK(SCHEME_CPTR_VAL(p));
00160   gcMARK(SCHEME_CPTR_TYPE(p));
00161   return
00162   gcBYTES_TO_WORDS(sizeof(Scheme_Cptr));
00163 }
00164 
00165 static int cpointer_obj_FIXUP(void *p) {
00166   gcFIXUP(SCHEME_CPTR_VAL(p));
00167   gcFIXUP(SCHEME_CPTR_TYPE(p));
00168   return
00169   gcBYTES_TO_WORDS(sizeof(Scheme_Cptr));
00170 }
00171 
00172 #define cpointer_obj_IS_ATOMIC 0
00173 #define cpointer_obj_IS_CONST_SIZE 1
00174 
00175 
00176 static int offset_cpointer_obj_SIZE(void *p) {
00177   return
00178   gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr));
00179 }
00180 
00181 static int offset_cpointer_obj_MARK(void *p) {
00182   gcMARK(SCHEME_CPTR_VAL(p));
00183   gcMARK(SCHEME_CPTR_TYPE(p));
00184   return
00185   gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr));
00186 }
00187 
00188 static int offset_cpointer_obj_FIXUP(void *p) {
00189   gcFIXUP(SCHEME_CPTR_VAL(p));
00190   gcFIXUP(SCHEME_CPTR_TYPE(p));
00191   return
00192   gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr));
00193 }
00194 
00195 #define offset_cpointer_obj_IS_ATOMIC 0
00196 #define offset_cpointer_obj_IS_CONST_SIZE 1
00197 
00198 
00199 static int second_of_cons_SIZE(void *p) {
00200   return
00201   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00202 }
00203 
00204 static int second_of_cons_MARK(void *p) {
00205   gcMARK(SCHEME_PTR2_VAL((Scheme_Object *)p));
00206   return
00207   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00208 }
00209 
00210 static int second_of_cons_FIXUP(void *p) {
00211   gcFIXUP(SCHEME_PTR2_VAL((Scheme_Object *)p));
00212   return
00213   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00214 }
00215 
00216 #define second_of_cons_IS_ATOMIC 0
00217 #define second_of_cons_IS_CONST_SIZE 1
00218 
00219 
00220 static int twoptr_obj_SIZE(void *p) {
00221   return
00222   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00223 }
00224 
00225 static int twoptr_obj_MARK(void *p) {
00226   gcMARK(SCHEME_PTR1_VAL((Scheme_Object *)p));
00227   gcMARK(SCHEME_PTR2_VAL((Scheme_Object *)p));
00228   return
00229   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00230 }
00231 
00232 static int twoptr_obj_FIXUP(void *p) {
00233   gcFIXUP(SCHEME_PTR1_VAL((Scheme_Object *)p));
00234   gcFIXUP(SCHEME_PTR2_VAL((Scheme_Object *)p));
00235   return
00236   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00237 }
00238 
00239 #define twoptr_obj_IS_ATOMIC 0
00240 #define twoptr_obj_IS_CONST_SIZE 1
00241 
00242 
00243 static int iptr_obj_SIZE(void *p) {
00244   return
00245   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00246 }
00247 
00248 static int iptr_obj_MARK(void *p) {
00249   gcMARK(SCHEME_IPTR_VAL((Scheme_Object *)p));
00250   return
00251   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00252 }
00253 
00254 static int iptr_obj_FIXUP(void *p) {
00255   gcFIXUP(SCHEME_IPTR_VAL((Scheme_Object *)p));
00256   return
00257   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
00258 }
00259 
00260 #define iptr_obj_IS_ATOMIC 0
00261 #define iptr_obj_IS_CONST_SIZE 1
00262 
00263 
00264 static int small_object_SIZE(void *p) {
00265   return
00266   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
00267 }
00268 
00269 static int small_object_MARK(void *p) {
00270   gcMARK(((Scheme_Small_Object *)p)->u.ptr_value);
00271 
00272   return
00273   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
00274 }
00275 
00276 static int small_object_FIXUP(void *p) {
00277   gcFIXUP(((Scheme_Small_Object *)p)->u.ptr_value);
00278 
00279   return
00280   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
00281 }
00282 
00283 #define small_object_IS_ATOMIC 0
00284 #define small_object_IS_CONST_SIZE 1
00285 
00286 
00287 static int app_rec_SIZE(void *p) {
00288   Scheme_App_Rec *r = (Scheme_App_Rec *)p;
00289 
00290   return
00291   gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 
00292                   + (r->num_args * sizeof(Scheme_Object *))
00293                   + ((r->num_args + 1) * sizeof(char))));
00294 }
00295 
00296 static int app_rec_MARK(void *p) {
00297   Scheme_App_Rec *r = (Scheme_App_Rec *)p;
00298 
00299   int i = r->num_args + 1;
00300   while (i--) 
00301     gcMARK(r->args[i]);
00302 
00303   return
00304   gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 
00305                   + (r->num_args * sizeof(Scheme_Object *))
00306                   + ((r->num_args + 1) * sizeof(char))));
00307 }
00308 
00309 static int app_rec_FIXUP(void *p) {
00310   Scheme_App_Rec *r = (Scheme_App_Rec *)p;
00311 
00312   int i = r->num_args + 1;
00313   while (i--) 
00314     gcFIXUP(r->args[i]);
00315 
00316   return
00317   gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 
00318                   + (r->num_args * sizeof(Scheme_Object *))
00319                   + ((r->num_args + 1) * sizeof(char))));
00320 }
00321 
00322 #define app_rec_IS_ATOMIC 0
00323 #define app_rec_IS_CONST_SIZE 0
00324 
00325 
00326 static int app2_rec_SIZE(void *p) {
00327   return
00328   gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec));
00329 }
00330 
00331 static int app2_rec_MARK(void *p) {
00332   Scheme_App2_Rec *r = (Scheme_App2_Rec *)p;
00333   gcMARK(r->rator);
00334   gcMARK(r->rand);
00335 
00336   return
00337   gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec));
00338 }
00339 
00340 static int app2_rec_FIXUP(void *p) {
00341   Scheme_App2_Rec *r = (Scheme_App2_Rec *)p;
00342   gcFIXUP(r->rator);
00343   gcFIXUP(r->rand);
00344 
00345   return
00346   gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec));
00347 }
00348 
00349 #define app2_rec_IS_ATOMIC 0
00350 #define app2_rec_IS_CONST_SIZE 1
00351 
00352 
00353 static int app3_rec_SIZE(void *p) {
00354   return
00355   gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec));
00356 }
00357 
00358 static int app3_rec_MARK(void *p) {
00359   Scheme_App3_Rec *r = (Scheme_App3_Rec *)p;
00360   gcMARK(r->rator);
00361   gcMARK(r->rand1);
00362   gcMARK(r->rand2);
00363 
00364   return
00365   gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec));
00366 }
00367 
00368 static int app3_rec_FIXUP(void *p) {
00369   Scheme_App3_Rec *r = (Scheme_App3_Rec *)p;
00370   gcFIXUP(r->rator);
00371   gcFIXUP(r->rand1);
00372   gcFIXUP(r->rand2);
00373 
00374   return
00375   gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec));
00376 }
00377 
00378 #define app3_rec_IS_ATOMIC 0
00379 #define app3_rec_IS_CONST_SIZE 1
00380 
00381 
00382 static int seq_rec_SIZE(void *p) {
00383   Scheme_Sequence *s = (Scheme_Sequence *)p;
00384 
00385   return
00386   gcBYTES_TO_WORDS((sizeof(Scheme_Sequence)
00387                   + ((s->count - 1) * sizeof(Scheme_Object *))));
00388 }
00389 
00390 static int seq_rec_MARK(void *p) {
00391   Scheme_Sequence *s = (Scheme_Sequence *)p;
00392 
00393   int i = s->count;
00394   while (i--)
00395     gcMARK(s->array[i]);
00396 
00397   return
00398   gcBYTES_TO_WORDS((sizeof(Scheme_Sequence)
00399                   + ((s->count - 1) * sizeof(Scheme_Object *))));
00400 }
00401 
00402 static int seq_rec_FIXUP(void *p) {
00403   Scheme_Sequence *s = (Scheme_Sequence *)p;
00404 
00405   int i = s->count;
00406   while (i--)
00407     gcFIXUP(s->array[i]);
00408 
00409   return
00410   gcBYTES_TO_WORDS((sizeof(Scheme_Sequence)
00411                   + ((s->count - 1) * sizeof(Scheme_Object *))));
00412 }
00413 
00414 #define seq_rec_IS_ATOMIC 0
00415 #define seq_rec_IS_CONST_SIZE 0
00416 
00417 
00418 static int branch_rec_SIZE(void *p) {
00419   return
00420   gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec));
00421 }
00422 
00423 static int branch_rec_MARK(void *p) {
00424   Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p;
00425   
00426   gcMARK(b->test);
00427   gcMARK(b->tbranch);
00428   gcMARK(b->fbranch);
00429 
00430   return
00431   gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec));
00432 }
00433 
00434 static int branch_rec_FIXUP(void *p) {
00435   Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p;
00436   
00437   gcFIXUP(b->test);
00438   gcFIXUP(b->tbranch);
00439   gcFIXUP(b->fbranch);
00440 
00441   return
00442   gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec));
00443 }
00444 
00445 #define branch_rec_IS_ATOMIC 0
00446 #define branch_rec_IS_CONST_SIZE 1
00447 
00448 
00449 static int unclosed_proc_SIZE(void *p) {
00450   return
00451   gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data));
00452 }
00453 
00454 static int unclosed_proc_MARK(void *p) {
00455   Scheme_Closure_Data *d = (Scheme_Closure_Data *)p;
00456 
00457   gcMARK(d->name);
00458   gcMARK(d->code);
00459   gcMARK(d->closure_map);
00460 #ifdef MZ_USE_JIT
00461   gcMARK(d->u.native_code);
00462   gcMARK(d->context);
00463 #endif
00464 
00465   return
00466   gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data));
00467 }
00468 
00469 static int unclosed_proc_FIXUP(void *p) {
00470   Scheme_Closure_Data *d = (Scheme_Closure_Data *)p;
00471 
00472   gcFIXUP(d->name);
00473   gcFIXUP(d->code);
00474   gcFIXUP(d->closure_map);
00475 #ifdef MZ_USE_JIT
00476   gcFIXUP(d->u.native_code);
00477   gcFIXUP(d->context);
00478 #endif
00479 
00480   return
00481   gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data));
00482 }
00483 
00484 #define unclosed_proc_IS_ATOMIC 0
00485 #define unclosed_proc_IS_CONST_SIZE 1
00486 
00487 
00488 static int let_value_SIZE(void *p) {
00489   return
00490   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value));
00491 }
00492 
00493 static int let_value_MARK(void *p) {
00494   Scheme_Let_Value *l = (Scheme_Let_Value *)p;
00495   
00496   gcMARK(l->value);
00497   gcMARK(l->body);
00498 
00499   return
00500   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value));
00501 }
00502 
00503 static int let_value_FIXUP(void *p) {
00504   Scheme_Let_Value *l = (Scheme_Let_Value *)p;
00505   
00506   gcFIXUP(l->value);
00507   gcFIXUP(l->body);
00508 
00509   return
00510   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value));
00511 }
00512 
00513 #define let_value_IS_ATOMIC 0
00514 #define let_value_IS_CONST_SIZE 1
00515 
00516 
00517 static int let_void_SIZE(void *p) {
00518   return
00519   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void));
00520 }
00521 
00522 static int let_void_MARK(void *p) {
00523   Scheme_Let_Void *l = (Scheme_Let_Void *)p;
00524 
00525   gcMARK(l->body);
00526   
00527   return
00528   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void));
00529 }
00530 
00531 static int let_void_FIXUP(void *p) {
00532   Scheme_Let_Void *l = (Scheme_Let_Void *)p;
00533 
00534   gcFIXUP(l->body);
00535   
00536   return
00537   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void));
00538 }
00539 
00540 #define let_void_IS_ATOMIC 0
00541 #define let_void_IS_CONST_SIZE 1
00542 
00543 
00544 static int letrec_SIZE(void *p) {
00545   return
00546   gcBYTES_TO_WORDS(sizeof(Scheme_Letrec));
00547 }
00548 
00549 static int letrec_MARK(void *p) {
00550   Scheme_Letrec *l = (Scheme_Letrec *)p;
00551   
00552   gcMARK(l->procs);
00553   gcMARK(l->body);
00554 
00555   return
00556   gcBYTES_TO_WORDS(sizeof(Scheme_Letrec));
00557 }
00558 
00559 static int letrec_FIXUP(void *p) {
00560   Scheme_Letrec *l = (Scheme_Letrec *)p;
00561   
00562   gcFIXUP(l->procs);
00563   gcFIXUP(l->body);
00564 
00565   return
00566   gcBYTES_TO_WORDS(sizeof(Scheme_Letrec));
00567 }
00568 
00569 #define letrec_IS_ATOMIC 0
00570 #define letrec_IS_CONST_SIZE 1
00571 
00572 
00573 static int let_one_SIZE(void *p) {
00574   return
00575   gcBYTES_TO_WORDS(sizeof(Scheme_Let_One));
00576 }
00577 
00578 static int let_one_MARK(void *p) {
00579   Scheme_Let_One *l = (Scheme_Let_One *)p;
00580   
00581   gcMARK(l->value);
00582   gcMARK(l->body);
00583 
00584   return
00585   gcBYTES_TO_WORDS(sizeof(Scheme_Let_One));
00586 }
00587 
00588 static int let_one_FIXUP(void *p) {
00589   Scheme_Let_One *l = (Scheme_Let_One *)p;
00590   
00591   gcFIXUP(l->value);
00592   gcFIXUP(l->body);
00593 
00594   return
00595   gcBYTES_TO_WORDS(sizeof(Scheme_Let_One));
00596 }
00597 
00598 #define let_one_IS_ATOMIC 0
00599 #define let_one_IS_CONST_SIZE 1
00600 
00601 
00602 static int with_cont_mark_SIZE(void *p) {
00603   return
00604   gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark));
00605 }
00606 
00607 static int with_cont_mark_MARK(void *p) {
00608   Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p;
00609 
00610   gcMARK(w->key);
00611   gcMARK(w->val);
00612   gcMARK(w->body);
00613 
00614   return
00615   gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark));
00616 }
00617 
00618 static int with_cont_mark_FIXUP(void *p) {
00619   Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p;
00620 
00621   gcFIXUP(w->key);
00622   gcFIXUP(w->val);
00623   gcFIXUP(w->body);
00624 
00625   return
00626   gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark));
00627 }
00628 
00629 #define with_cont_mark_IS_ATOMIC 0
00630 #define with_cont_mark_IS_CONST_SIZE 1
00631 
00632 
00633 static int comp_let_value_SIZE(void *p) {
00634   return
00635   gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value));
00636 }
00637 
00638 static int comp_let_value_MARK(void *p) {
00639   Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p;
00640 
00641   gcMARK(c->flags);
00642   gcMARK(c->value);
00643   gcMARK(c->body);
00644 
00645   return
00646   gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value));
00647 }
00648 
00649 static int comp_let_value_FIXUP(void *p) {
00650   Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p;
00651 
00652   gcFIXUP(c->flags);
00653   gcFIXUP(c->value);
00654   gcFIXUP(c->body);
00655 
00656   return
00657   gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value));
00658 }
00659 
00660 #define comp_let_value_IS_ATOMIC 0
00661 #define comp_let_value_IS_CONST_SIZE 1
00662 
00663 
00664 static int let_header_SIZE(void *p) {
00665   return
00666   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header));
00667 }
00668 
00669 static int let_header_MARK(void *p) {
00670   Scheme_Let_Header *h = (Scheme_Let_Header *)p;
00671   
00672   gcMARK(h->body);
00673 
00674   return
00675   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header));
00676 }
00677 
00678 static int let_header_FIXUP(void *p) {
00679   Scheme_Let_Header *h = (Scheme_Let_Header *)p;
00680   
00681   gcFIXUP(h->body);
00682 
00683   return
00684   gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header));
00685 }
00686 
00687 #define let_header_IS_ATOMIC 0
00688 #define let_header_IS_CONST_SIZE 1
00689 
00690 
00691 static int prim_proc_SIZE(void *p) {
00692   Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p;
00693 
00694   return
00695   ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE)
00696    ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure))
00697       + ((Scheme_Primitive_Closure *)prim)->count - 1)
00698    : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00699       ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity))
00700       : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc))));
00701 }
00702 
00703 static int prim_proc_MARK(void *p) {
00704   Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p;
00705 
00706   gcMARK(prim->name);
00707   if (prim->mina < 0) {
00708     gcMARK(prim->mu.cases);
00709   }
00710   if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) {
00711     Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim;
00712     int i;
00713     for (i = cc->count; i--; ) {
00714       gcMARK(cc->val[i]);
00715     }
00716   }  
00717   
00718   return
00719   ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE)
00720    ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure))
00721       + ((Scheme_Primitive_Closure *)prim)->count - 1)
00722    : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00723       ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity))
00724       : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc))));
00725 }
00726 
00727 static int prim_proc_FIXUP(void *p) {
00728   Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p;
00729 
00730   gcFIXUP(prim->name);
00731   if (prim->mina < 0) {
00732     gcFIXUP(prim->mu.cases);
00733   }
00734   if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) {
00735     Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim;
00736     int i;
00737     for (i = cc->count; i--; ) {
00738       gcFIXUP(cc->val[i]);
00739     }
00740   }  
00741   
00742   return
00743   ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE)
00744    ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure))
00745       + ((Scheme_Primitive_Closure *)prim)->count - 1)
00746    : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00747       ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity))
00748       : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc))));
00749 }
00750 
00751 #define prim_proc_IS_ATOMIC 0
00752 #define prim_proc_IS_CONST_SIZE 0
00753 
00754 
00755 static int closed_prim_proc_SIZE(void *p) {
00756   Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p;
00757 
00758   return
00759   ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00760    ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity))
00761    : ((c->mina == -2)
00762       ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc))
00763       : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc))));
00764 }
00765 
00766 static int closed_prim_proc_MARK(void *p) {
00767   Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p;
00768 
00769   gcMARK(c->name);
00770   gcMARK(SCHEME_CLSD_PRIM_DATA(c));
00771   if (c->mina == -2) {
00772     gcMARK(((Scheme_Closed_Case_Primitive_Proc *)c)->cases);
00773   }
00774   
00775   return
00776   ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00777    ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity))
00778    : ((c->mina == -2)
00779       ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc))
00780       : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc))));
00781 }
00782 
00783 static int closed_prim_proc_FIXUP(void *p) {
00784   Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p;
00785 
00786   gcFIXUP(c->name);
00787   gcFIXUP(SCHEME_CLSD_PRIM_DATA(c));
00788   if (c->mina == -2) {
00789     gcFIXUP(((Scheme_Closed_Case_Primitive_Proc *)c)->cases);
00790   }
00791   
00792   return
00793   ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT)
00794    ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity))
00795    : ((c->mina == -2)
00796       ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc))
00797       : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc))));
00798 }
00799 
00800 #define closed_prim_proc_IS_ATOMIC 0
00801 #define closed_prim_proc_IS_CONST_SIZE 0
00802 
00803 
00804 static int scm_closure_SIZE(void *p) {
00805   Scheme_Closure *c = (Scheme_Closure *)p;
00806   int closure_size = (c->code 
00807                       ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size
00808                       : 0);
00809 
00810   return
00811   gcBYTES_TO_WORDS((sizeof(Scheme_Closure)
00812                   + (closure_size - 1) * sizeof(Scheme_Object *)));
00813 }
00814 
00815 static int scm_closure_MARK(void *p) {
00816   Scheme_Closure *c = (Scheme_Closure *)p;
00817   int closure_size = (c->code 
00818                       ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size
00819                       : 0);
00820 
00821 
00822   int i = closure_size;
00823   while (i--)
00824     gcMARK(c->vals[i]);
00825   gcMARK(c->code);
00826   
00827   return
00828   gcBYTES_TO_WORDS((sizeof(Scheme_Closure)
00829                   + (closure_size - 1) * sizeof(Scheme_Object *)));
00830 }
00831 
00832 static int scm_closure_FIXUP(void *p) {
00833   Scheme_Closure *c = (Scheme_Closure *)p;
00834   int closure_size = (c->code 
00835                       ? ((Scheme_Closure_Data *)GC_resolve(c->code))->closure_size
00836                       : 0);
00837 
00838 
00839   int i = closure_size;
00840   while (i--)
00841     gcFIXUP(c->vals[i]);
00842   gcFIXUP(c->code);
00843   
00844   return
00845   gcBYTES_TO_WORDS((sizeof(Scheme_Closure)
00846                   + (closure_size - 1) * sizeof(Scheme_Object *)));
00847 }
00848 
00849 #define scm_closure_IS_ATOMIC 0
00850 #define scm_closure_IS_CONST_SIZE 0
00851 
00852 
00853 static int case_closure_SIZE(void *p) {
00854   Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p;
00855 
00856   return
00857   gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda)
00858                   + ((c->count - 1) * sizeof(Scheme_Object *))));
00859 }
00860 
00861 static int case_closure_MARK(void *p) {
00862   Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p;
00863 
00864   int i;
00865   
00866   for (i = c->count; i--; )
00867     gcMARK(c->array[i]);
00868   gcMARK(c->name);
00869 #ifdef MZ_USE_JIT
00870   gcMARK(c->native_code);
00871 #endif
00872 
00873   return
00874   gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda)
00875                   + ((c->count - 1) * sizeof(Scheme_Object *))));
00876 }
00877 
00878 static int case_closure_FIXUP(void *p) {
00879   Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p;
00880 
00881   int i;
00882   
00883   for (i = c->count; i--; )
00884     gcFIXUP(c->array[i]);
00885   gcFIXUP(c->name);
00886 #ifdef MZ_USE_JIT
00887   gcFIXUP(c->native_code);
00888 #endif
00889 
00890   return
00891   gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda)
00892                   + ((c->count - 1) * sizeof(Scheme_Object *))));
00893 }
00894 
00895 #define case_closure_IS_ATOMIC 0
00896 #define case_closure_IS_CONST_SIZE 0
00897 
00898 
00899 static int cont_proc_SIZE(void *p) {
00900   return
00901   gcBYTES_TO_WORDS(sizeof(Scheme_Cont));
00902 }
00903 
00904 static int cont_proc_MARK(void *p) {
00905   Scheme_Cont *c = (Scheme_Cont *)p;
00906   
00907   gcMARK(c->dw);
00908   gcMARK(c->prompt_tag);
00909   gcMARK(c->meta_continuation);
00910   gcMARK(c->common_dw);
00911   gcMARK(c->save_overflow);
00912   gcMARK(c->runstack_copied);
00913   gcMARK(c->runstack_owner);
00914   gcMARK(c->cont_mark_stack_copied);
00915   gcMARK(c->cont_mark_stack_owner);
00916   gcMARK(c->init_config);
00917   gcMARK(c->init_break_cell);
00918 #ifdef MZ_USE_JIT
00919   gcMARK(c->native_trace);
00920 #endif
00921 
00922   MARK_jmpup(&c->buf);
00923   MARK_cjs(&c->cjs);
00924   MARK_stack_state(&c->ss);
00925   gcMARK(c->barrier_prompt);
00926   if (!GC_merely_accounting()) {
00927     gcMARK(c->runstack_start);
00928     gcMARK(c->runstack_saved);
00929   }
00930 
00931   gcMARK(c->prompt_id);
00932   gcMARK(c->prompt_buf);
00933 
00934   gcMARK(c->value);
00935   gcMARK(c->resume_to);
00936   gcMARK(c->use_next_cont);
00937   gcMARK(c->extra_marks);
00938   gcMARK(c->shortcut_prompt);
00939   
00940   return
00941   gcBYTES_TO_WORDS(sizeof(Scheme_Cont));
00942 }
00943 
00944 static int cont_proc_FIXUP(void *p) {
00945   Scheme_Cont *c = (Scheme_Cont *)p;
00946   
00947   gcFIXUP(c->dw);
00948   gcFIXUP(c->prompt_tag);
00949   gcFIXUP(c->meta_continuation);
00950   gcFIXUP(c->common_dw);
00951   gcFIXUP(c->save_overflow);
00952   gcFIXUP(c->runstack_copied);
00953   gcFIXUP(c->runstack_owner);
00954   gcFIXUP(c->cont_mark_stack_copied);
00955   gcFIXUP(c->cont_mark_stack_owner);
00956   gcFIXUP(c->init_config);
00957   gcFIXUP(c->init_break_cell);
00958 #ifdef MZ_USE_JIT
00959   gcFIXUP(c->native_trace);
00960 #endif
00961 
00962   FIXUP_jmpup(&c->buf);
00963   FIXUP_cjs(&c->cjs);
00964   FIXUP_stack_state(&c->ss);
00965   gcFIXUP(c->barrier_prompt);
00966   if (!GC_merely_accounting()) {
00967     gcFIXUP(c->runstack_start);
00968     gcFIXUP(c->runstack_saved);
00969   }
00970 
00971   gcFIXUP(c->prompt_id);
00972   gcFIXUP(c->prompt_buf);
00973 
00974   gcFIXUP(c->value);
00975   gcFIXUP(c->resume_to);
00976   gcFIXUP(c->use_next_cont);
00977   gcFIXUP(c->extra_marks);
00978   gcFIXUP(c->shortcut_prompt);
00979   
00980   return
00981   gcBYTES_TO_WORDS(sizeof(Scheme_Cont));
00982 }
00983 
00984 #define cont_proc_IS_ATOMIC 0
00985 #define cont_proc_IS_CONST_SIZE 1
00986 
00987 
00988 static int meta_cont_proc_SIZE(void *p) {
00989   return
00990   gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation));
00991 }
00992 
00993 static int meta_cont_proc_MARK(void *p) {
00994   Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p;
00995   
00996   gcMARK(c->prompt_tag);
00997   gcMARK(c->overflow);
00998   gcMARK(c->next);
00999   gcMARK(c->cont_mark_stack_copied);
01000   gcMARK(c->cont);
01001 
01002   return
01003   gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation));
01004 }
01005 
01006 static int meta_cont_proc_FIXUP(void *p) {
01007   Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p;
01008   
01009   gcFIXUP(c->prompt_tag);
01010   gcFIXUP(c->overflow);
01011   gcFIXUP(c->next);
01012   gcFIXUP(c->cont_mark_stack_copied);
01013   gcFIXUP(c->cont);
01014 
01015   return
01016   gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation));
01017 }
01018 
01019 #define meta_cont_proc_IS_ATOMIC 0
01020 #define meta_cont_proc_IS_CONST_SIZE 1
01021 
01022 
01023 static int mark_dyn_wind_SIZE(void *p) {
01024   return
01025   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind));
01026 }
01027 
01028 static int mark_dyn_wind_MARK(void *p) {
01029   Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p;
01030   
01031   gcMARK(dw->id);
01032   gcMARK(dw->data);
01033   gcMARK(dw->prompt_tag);
01034   gcMARK(dw->prev);
01035     
01036   MARK_stack_state(&dw->envss);
01037 
01038   return
01039   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind));
01040 }
01041 
01042 static int mark_dyn_wind_FIXUP(void *p) {
01043   Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p;
01044   
01045   gcFIXUP(dw->id);
01046   gcFIXUP(dw->data);
01047   gcFIXUP(dw->prompt_tag);
01048   gcFIXUP(dw->prev);
01049     
01050   FIXUP_stack_state(&dw->envss);
01051 
01052   return
01053   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind));
01054 }
01055 
01056 #define mark_dyn_wind_IS_ATOMIC 0
01057 #define mark_dyn_wind_IS_CONST_SIZE 1
01058 
01059 
01060 static int mark_overflow_SIZE(void *p) {
01061   return
01062   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow));
01063 }
01064 
01065 static int mark_overflow_MARK(void *p) {
01066   Scheme_Overflow *o = (Scheme_Overflow *)p;
01067 
01068   gcMARK(o->prev);
01069   gcMARK(o->jmp);
01070   gcMARK(o->id);
01071 
01072   return
01073   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow));
01074 }
01075 
01076 static int mark_overflow_FIXUP(void *p) {
01077   Scheme_Overflow *o = (Scheme_Overflow *)p;
01078 
01079   gcFIXUP(o->prev);
01080   gcFIXUP(o->jmp);
01081   gcFIXUP(o->id);
01082 
01083   return
01084   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow));
01085 }
01086 
01087 #define mark_overflow_IS_ATOMIC 0
01088 #define mark_overflow_IS_CONST_SIZE 1
01089 
01090 
01091 static int mark_overflow_jmp_SIZE(void *p) {
01092   return
01093   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp));
01094 }
01095 
01096 static int mark_overflow_jmp_MARK(void *p) {
01097   Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p;
01098 
01099   MARK_jmpup(&o->cont);
01100 
01101   return
01102   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp));
01103 }
01104 
01105 static int mark_overflow_jmp_FIXUP(void *p) {
01106   Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p;
01107 
01108   FIXUP_jmpup(&o->cont);
01109 
01110   return
01111   gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp));
01112 }
01113 
01114 #define mark_overflow_jmp_IS_ATOMIC 0
01115 #define mark_overflow_jmp_IS_CONST_SIZE 1
01116 
01117 
01118 static int escaping_cont_proc_SIZE(void *p) {
01119   return
01120   gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont));
01121 }
01122 
01123 static int escaping_cont_proc_MARK(void *p) {
01124   Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p;
01125 
01126 #ifdef MZ_USE_JIT
01127   gcMARK(c->native_trace);
01128 #endif
01129 
01130   gcMARK(c->barrier_prompt);
01131   MARK_stack_state(&c->envss);
01132 
01133   return
01134   gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont));
01135 }
01136 
01137 static int escaping_cont_proc_FIXUP(void *p) {
01138   Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p;
01139 
01140 #ifdef MZ_USE_JIT
01141   gcFIXUP(c->native_trace);
01142 #endif
01143 
01144   gcFIXUP(c->barrier_prompt);
01145   FIXUP_stack_state(&c->envss);
01146 
01147   return
01148   gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont));
01149 }
01150 
01151 #define escaping_cont_proc_IS_ATOMIC 0
01152 #define escaping_cont_proc_IS_CONST_SIZE 1
01153 
01154 
01155 static int char_obj_SIZE(void *p) {
01156   return
01157   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
01158 }
01159 
01160 static int char_obj_MARK(void *p) {
01161   return
01162   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
01163 }
01164 
01165 static int char_obj_FIXUP(void *p) {
01166   return
01167   gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object));
01168 }
01169 
01170 #define char_obj_IS_ATOMIC 1
01171 #define char_obj_IS_CONST_SIZE 1
01172 
01173 
01174 static int bignum_obj_SIZE(void *p) {
01175   Scheme_Bignum *b = (Scheme_Bignum *)p;
01176 
01177   return
01178   ((!SCHEME_BIGINLINE(b))
01179    ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum))
01180    : gcBYTES_TO_WORDS(sizeof(Small_Bignum)));
01181 }
01182 
01183 static int bignum_obj_MARK(void *p) {
01184   Scheme_Bignum *b = (Scheme_Bignum *)p;
01185 
01186   if (!SCHEME_BIGINLINE(b)) {
01187     gcMARK(b->digits);
01188   } else {
01189     
01190   }
01191 
01192   return
01193   ((!SCHEME_BIGINLINE(b))
01194    ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum))
01195    : gcBYTES_TO_WORDS(sizeof(Small_Bignum)));
01196 }
01197 
01198 static int bignum_obj_FIXUP(void *p) {
01199   Scheme_Bignum *b = (Scheme_Bignum *)p;
01200 
01201   if (!SCHEME_BIGINLINE(b)) {
01202     gcFIXUP(b->digits);
01203   } else {
01204     b->digits = ((Small_Bignum *)GC_fixup_self(b))->v;
01205   }
01206 
01207   return
01208   ((!SCHEME_BIGINLINE(b))
01209    ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum))
01210    : gcBYTES_TO_WORDS(sizeof(Small_Bignum)));
01211 }
01212 
01213 #define bignum_obj_IS_ATOMIC 0
01214 #define bignum_obj_IS_CONST_SIZE 0
01215 
01216 
01217 static int rational_obj_SIZE(void *p) {
01218   return
01219   gcBYTES_TO_WORDS(sizeof(Scheme_Rational));
01220 }
01221 
01222 static int rational_obj_MARK(void *p) {
01223   Scheme_Rational *r = (Scheme_Rational *)p;
01224   
01225   gcMARK(r->num);
01226   gcMARK(r->denom);
01227 
01228   return
01229   gcBYTES_TO_WORDS(sizeof(Scheme_Rational));
01230 }
01231 
01232 static int rational_obj_FIXUP(void *p) {
01233   Scheme_Rational *r = (Scheme_Rational *)p;
01234   
01235   gcFIXUP(r->num);
01236   gcFIXUP(r->denom);
01237 
01238   return
01239   gcBYTES_TO_WORDS(sizeof(Scheme_Rational));
01240 }
01241 
01242 #define rational_obj_IS_ATOMIC 0
01243 #define rational_obj_IS_CONST_SIZE 1
01244 
01245 
01246 static int float_obj_SIZE(void *p) {
01247   return
01248 #ifdef MZ_USE_SINGLE_FLOATS
01249   gcBYTES_TO_WORDS(sizeof(Scheme_Float));
01250 #else
01251   0;
01252 #endif
01253 }
01254 
01255 static int float_obj_MARK(void *p) {
01256   return
01257 #ifdef MZ_USE_SINGLE_FLOATS
01258   gcBYTES_TO_WORDS(sizeof(Scheme_Float));
01259 #else
01260   0;
01261 #endif
01262 }
01263 
01264 static int float_obj_FIXUP(void *p) {
01265   return
01266 #ifdef MZ_USE_SINGLE_FLOATS
01267   gcBYTES_TO_WORDS(sizeof(Scheme_Float));
01268 #else
01269   0;
01270 #endif
01271 }
01272 
01273 #define float_obj_IS_ATOMIC 1
01274 #define float_obj_IS_CONST_SIZE 0
01275 
01276 
01277 static int double_obj_SIZE(void *p) {
01278   return
01279   gcBYTES_TO_WORDS(sizeof(Scheme_Double));
01280 }
01281 
01282 static int double_obj_MARK(void *p) {
01283   return
01284   gcBYTES_TO_WORDS(sizeof(Scheme_Double));
01285 }
01286 
01287 static int double_obj_FIXUP(void *p) {
01288   return
01289   gcBYTES_TO_WORDS(sizeof(Scheme_Double));
01290 }
01291 
01292 #define double_obj_IS_ATOMIC 1
01293 #define double_obj_IS_CONST_SIZE 1
01294 
01295 
01296 static int complex_obj_SIZE(void *p) {
01297   return
01298   gcBYTES_TO_WORDS(sizeof(Scheme_Complex));
01299 }
01300 
01301 static int complex_obj_MARK(void *p) {
01302   Scheme_Complex *c = (Scheme_Complex *)p;
01303   
01304   gcMARK(c->r);
01305   gcMARK(c->i);
01306   
01307   return
01308   gcBYTES_TO_WORDS(sizeof(Scheme_Complex));
01309 }
01310 
01311 static int complex_obj_FIXUP(void *p) {
01312   Scheme_Complex *c = (Scheme_Complex *)p;
01313   
01314   gcFIXUP(c->r);
01315   gcFIXUP(c->i);
01316   
01317   return
01318   gcBYTES_TO_WORDS(sizeof(Scheme_Complex));
01319 }
01320 
01321 #define complex_obj_IS_ATOMIC 0
01322 #define complex_obj_IS_CONST_SIZE 1
01323 
01324 
01325 static int string_obj_SIZE(void *p) {
01326   return
01327   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01328 }
01329 
01330 static int string_obj_MARK(void *p) {
01331   Scheme_Object *o = (Scheme_Object *)p;
01332   gcMARK(SCHEME_CHAR_STR_VAL(o));
01333 
01334   return
01335   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01336 }
01337 
01338 static int string_obj_FIXUP(void *p) {
01339   Scheme_Object *o = (Scheme_Object *)p;
01340   gcFIXUP(SCHEME_CHAR_STR_VAL(o));
01341 
01342   return
01343   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01344 }
01345 
01346 #define string_obj_IS_ATOMIC 0
01347 #define string_obj_IS_CONST_SIZE 1
01348 
01349 
01350 static int bstring_obj_SIZE(void *p) {
01351   return
01352   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01353 }
01354 
01355 static int bstring_obj_MARK(void *p) {
01356   Scheme_Object *o = (Scheme_Object *)p;
01357   gcMARK(SCHEME_BYTE_STR_VAL(o));
01358 
01359   return
01360   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01361 }
01362 
01363 static int bstring_obj_FIXUP(void *p) {
01364   Scheme_Object *o = (Scheme_Object *)p;
01365   gcFIXUP(SCHEME_BYTE_STR_VAL(o));
01366 
01367   return
01368   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01369 }
01370 
01371 #define bstring_obj_IS_ATOMIC 0
01372 #define bstring_obj_IS_CONST_SIZE 1
01373 
01374 
01375 static int symbol_obj_SIZE(void *p) {
01376   Scheme_Symbol *s = (Scheme_Symbol *)p;
01377 
01378   return
01379   gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len - 3);
01380 }
01381 
01382 static int symbol_obj_MARK(void *p) {
01383   Scheme_Symbol *s = (Scheme_Symbol *)p;
01384 
01385   return
01386   gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len - 3);
01387 }
01388 
01389 static int symbol_obj_FIXUP(void *p) {
01390   Scheme_Symbol *s = (Scheme_Symbol *)p;
01391 
01392   return
01393   gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len - 3);
01394 }
01395 
01396 #define symbol_obj_IS_ATOMIC 1
01397 #define symbol_obj_IS_CONST_SIZE 0
01398 
01399 
01400 static int cons_cell_SIZE(void *p) {
01401   return
01402   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01403 }
01404 
01405 static int cons_cell_MARK(void *p) {
01406   Scheme_Object *o = (Scheme_Object *)p;
01407   
01408   gcMARK(SCHEME_CAR(o));
01409   gcMARK(SCHEME_CDR(o));
01410 
01411   return
01412   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01413 }
01414 
01415 static int cons_cell_FIXUP(void *p) {
01416   Scheme_Object *o = (Scheme_Object *)p;
01417   
01418   gcFIXUP(SCHEME_CAR(o));
01419   gcFIXUP(SCHEME_CDR(o));
01420 
01421   return
01422   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01423 }
01424 
01425 #define cons_cell_IS_ATOMIC 0
01426 #define cons_cell_IS_CONST_SIZE 1
01427 
01428 
01429 static int vector_obj_SIZE(void *p) {
01430   Scheme_Vector *vec = (Scheme_Vector *)p;
01431 
01432   return
01433   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
01434                   + ((vec->size - 1) * sizeof(Scheme_Object *))));
01435 }
01436 
01437 static int vector_obj_MARK(void *p) {
01438   Scheme_Vector *vec = (Scheme_Vector *)p;
01439 
01440   int i;
01441   for (i = vec->size; i--; )
01442     gcMARK(vec->els[i]);
01443 
01444   return
01445   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
01446                   + ((vec->size - 1) * sizeof(Scheme_Object *))));
01447 }
01448 
01449 static int vector_obj_FIXUP(void *p) {
01450   Scheme_Vector *vec = (Scheme_Vector *)p;
01451 
01452   int i;
01453   for (i = vec->size; i--; )
01454     gcFIXUP(vec->els[i]);
01455 
01456   return
01457   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
01458                   + ((vec->size - 1) * sizeof(Scheme_Object *))));
01459 }
01460 
01461 #define vector_obj_IS_ATOMIC 0
01462 #define vector_obj_IS_CONST_SIZE 0
01463 
01464 
01465 static int input_port_SIZE(void *p) {
01466   return
01467   gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port));
01468 }
01469 
01470 static int input_port_MARK(void *p) {
01471   Scheme_Input_Port *ip = (Scheme_Input_Port *)p;
01472   
01473   gcMARK(ip->sub_type);
01474   gcMARK(ip->port_data);
01475   gcMARK(ip->name);
01476   gcMARK(ip->peeked_read);
01477   gcMARK(ip->peeked_write);
01478   gcMARK(ip->read_handler);
01479   gcMARK(ip->mref);
01480   gcMARK(ip->output_half);
01481   gcMARK(ip->special);
01482   gcMARK(ip->ungotten_special);
01483   gcMARK(ip->progress_evt);
01484   gcMARK(ip->input_lock);
01485   gcMARK(ip->input_giveup);
01486   gcMARK(ip->input_extras);
01487   gcMARK(ip->input_extras_ready);
01488   gcMARK(ip->unless);
01489   gcMARK(ip->unless_cache);
01490 
01491   return
01492   gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port));
01493 }
01494 
01495 static int input_port_FIXUP(void *p) {
01496   Scheme_Input_Port *ip = (Scheme_Input_Port *)p;
01497   
01498   gcFIXUP(ip->sub_type);
01499   gcFIXUP(ip->port_data);
01500   gcFIXUP(ip->name);
01501   gcFIXUP(ip->peeked_read);
01502   gcFIXUP(ip->peeked_write);
01503   gcFIXUP(ip->read_handler);
01504   gcFIXUP(ip->mref);
01505   gcFIXUP(ip->output_half);
01506   gcFIXUP(ip->special);
01507   gcFIXUP(ip->ungotten_special);
01508   gcFIXUP(ip->progress_evt);
01509   gcFIXUP(ip->input_lock);
01510   gcFIXUP(ip->input_giveup);
01511   gcFIXUP(ip->input_extras);
01512   gcFIXUP(ip->input_extras_ready);
01513   gcFIXUP(ip->unless);
01514   gcFIXUP(ip->unless_cache);
01515 
01516   return
01517   gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port));
01518 }
01519 
01520 #define input_port_IS_ATOMIC 0
01521 #define input_port_IS_CONST_SIZE 1
01522 
01523 
01524 static int output_port_SIZE(void *p) {
01525   return
01526   gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port));
01527 }
01528 
01529 static int output_port_MARK(void *p) {
01530   Scheme_Output_Port *op = (Scheme_Output_Port *)p;
01531 
01532   gcMARK(op->sub_type);
01533   gcMARK(op->port_data);
01534   gcMARK(op->name);
01535   gcMARK(op->display_handler);
01536   gcMARK(op->write_handler);
01537   gcMARK(op->print_handler);
01538   gcMARK(op->mref);
01539   gcMARK(op->input_half);
01540 
01541   return
01542   gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port));
01543 }
01544 
01545 static int output_port_FIXUP(void *p) {
01546   Scheme_Output_Port *op = (Scheme_Output_Port *)p;
01547 
01548   gcFIXUP(op->sub_type);
01549   gcFIXUP(op->port_data);
01550   gcFIXUP(op->name);
01551   gcFIXUP(op->display_handler);
01552   gcFIXUP(op->write_handler);
01553   gcFIXUP(op->print_handler);
01554   gcFIXUP(op->mref);
01555   gcFIXUP(op->input_half);
01556 
01557   return
01558   gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port));
01559 }
01560 
01561 #define output_port_IS_ATOMIC 0
01562 #define output_port_IS_CONST_SIZE 1
01563 
01564 
01565 
01566 static int syntax_compiler_SIZE(void *p) {
01567   return
01568   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01569 }
01570 
01571 static int syntax_compiler_MARK(void *p) {
01572   return
01573   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01574 }
01575 
01576 static int syntax_compiler_FIXUP(void *p) {
01577   return
01578   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
01579 }
01580 
01581 #define syntax_compiler_IS_ATOMIC 1
01582 #define syntax_compiler_IS_CONST_SIZE 1
01583 
01584 
01585 static int thread_val_SIZE(void *p) {
01586   return
01587   gcBYTES_TO_WORDS(sizeof(Scheme_Thread));
01588 }
01589 
01590 static int thread_val_MARK(void *p) {
01591   Scheme_Thread *pr = (Scheme_Thread *)p;
01592   
01593   gcMARK(pr->next);
01594   gcMARK(pr->prev);
01595 
01596   gcMARK(pr->t_set_parent);
01597   gcMARK(pr->t_set_next);
01598   gcMARK(pr->t_set_prev);
01599 
01600   MARK_cjs(&pr->cjs);
01601   gcMARK(pr->decompose_mc);
01602 
01603   gcMARK(pr->cell_values);
01604   gcMARK(pr->init_config);
01605   gcMARK(pr->init_break_cell);
01606 
01607   if (!pr->runstack_owner
01608       || !GC_merely_accounting()
01609       || (*pr->runstack_owner == pr)) {
01610     Scheme_Object **rs = pr->runstack_start;
01611     gcMARK( pr->runstack_start);
01612     if (pr->runstack != pr->runstack_start + (pr->runstack - rs))
01613       pr->runstack = pr->runstack_start + (pr->runstack - rs);
01614 
01615     gcMARK(pr->runstack_saved);
01616   }
01617   gcMARK(pr->runstack_owner);
01618   gcMARK(pr->runstack_swapped);
01619   pr->spare_runstack = NULL; /* just in case */
01620 
01621   gcMARK(pr->meta_prompt);
01622   gcMARK(pr->meta_continuation);
01623   
01624   gcMARK(pr->cont_mark_stack_segments);
01625   gcMARK(pr->cont_mark_stack_owner);
01626   gcMARK(pr->cont_mark_stack_swapped);
01627 
01628   MARK_jmpup(&pr->jmpup_buf);
01629   
01630   gcMARK(pr->dw);
01631   
01632   gcMARK(pr->nester);
01633   gcMARK(pr->nestee);
01634   
01635   gcMARK(pr->blocker);
01636   gcMARK(pr->overflow);
01637 
01638   gcMARK(pr->return_marks_to);
01639   gcMARK(pr->returned_marks);
01640   
01641   gcMARK(pr->current_local_env);
01642   gcMARK(pr->current_local_mark);
01643   gcMARK(pr->current_local_name);
01644   gcMARK(pr->current_local_certs);
01645   gcMARK(pr->current_local_modidx);
01646   gcMARK(pr->current_local_menv);
01647   gcMARK(pr->current_local_bindings);
01648 
01649   gcMARK(pr->current_mt);
01650 
01651   gcMARK(pr->constant_folding);
01652   gcMARK(pr->reading_delayed);
01653   
01654   gcMARK(pr->overflow_reply);
01655 
01656   gcMARK(pr->values_buffer);
01657 
01658   gcMARK(pr->tail_buffer);
01659   
01660   gcMARK(pr->ku.eval.wait_expr);
01661 
01662   gcMARK(pr->ku.apply.tail_rator);
01663   gcMARK(pr->ku.apply.tail_rands);
01664 
01665   gcMARK(pr->ku.multiple.array);
01666 
01667   gcMARK(pr->ku.k.p1);
01668   gcMARK(pr->ku.k.p2);
01669   gcMARK(pr->ku.k.p3);
01670   gcMARK(pr->ku.k.p4);
01671   gcMARK(pr->ku.k.p5);
01672   
01673   gcMARK(pr->list_stack);
01674   
01675   gcMARK(pr->kill_data);
01676   gcMARK(pr->private_kill_data);
01677   gcMARK(pr->private_kill_next);
01678   
01679   gcMARK(pr->user_tls);
01680   gcMARK(pr->gmp_tls_data);
01681   
01682   gcMARK(pr->mr_hop);
01683   gcMARK(pr->mref);
01684   gcMARK(pr->extra_mrefs);
01685 
01686   gcMARK(pr->name);
01687 
01688   gcMARK(pr->transitive_resumes);
01689 
01690   gcMARK(pr->suspended_box);
01691   gcMARK(pr->resumed_box);
01692   gcMARK(pr->dead_box);
01693   gcMARK(pr->running_box);
01694 
01695   gcMARK(pr->mbox_first);
01696   gcMARK(pr->mbox_last);
01697   gcMARK(pr->mbox_sema);
01698   return
01699   gcBYTES_TO_WORDS(sizeof(Scheme_Thread));
01700 }
01701 
01702 static int thread_val_FIXUP(void *p) {
01703   Scheme_Thread *pr = (Scheme_Thread *)p;
01704   
01705   gcFIXUP(pr->next);
01706   gcFIXUP(pr->prev);
01707 
01708   gcFIXUP(pr->t_set_parent);
01709   gcFIXUP(pr->t_set_next);
01710   gcFIXUP(pr->t_set_prev);
01711 
01712   FIXUP_cjs(&pr->cjs);
01713   gcFIXUP(pr->decompose_mc);
01714 
01715   gcFIXUP(pr->cell_values);
01716   gcFIXUP(pr->init_config);
01717   gcFIXUP(pr->init_break_cell);
01718 
01719   if (!pr->runstack_owner
01720       || !GC_merely_accounting()
01721       || (*pr->runstack_owner == pr)) {
01722     Scheme_Object **rs = pr->runstack_start;
01723     gcFIXUP_TYPED_NOW(Scheme_Object **, pr->runstack_start);
01724     if (pr->runstack != pr->runstack_start + (pr->runstack - rs))
01725       pr->runstack = pr->runstack_start + (pr->runstack - rs);
01726 
01727     gcFIXUP(pr->runstack_saved);
01728   }
01729   gcFIXUP(pr->runstack_owner);
01730   gcFIXUP(pr->runstack_swapped);
01731   pr->spare_runstack = NULL; /* just in case */
01732 
01733   gcFIXUP(pr->meta_prompt);
01734   gcFIXUP(pr->meta_continuation);
01735   
01736   gcFIXUP(pr->cont_mark_stack_segments);
01737   gcFIXUP(pr->cont_mark_stack_owner);
01738   gcFIXUP(pr->cont_mark_stack_swapped);
01739 
01740   FIXUP_jmpup(&pr->jmpup_buf);
01741   
01742   gcFIXUP(pr->dw);
01743   
01744   gcFIXUP(pr->nester);
01745   gcFIXUP(pr->nestee);
01746   
01747   gcFIXUP(pr->blocker);
01748   gcFIXUP(pr->overflow);
01749 
01750   gcFIXUP(pr->return_marks_to);
01751   gcFIXUP(pr->returned_marks);
01752   
01753   gcFIXUP(pr->current_local_env);
01754   gcFIXUP(pr->current_local_mark);
01755   gcFIXUP(pr->current_local_name);
01756   gcFIXUP(pr->current_local_certs);
01757   gcFIXUP(pr->current_local_modidx);
01758   gcFIXUP(pr->current_local_menv);
01759   gcFIXUP(pr->current_local_bindings);
01760 
01761   gcFIXUP(pr->current_mt);
01762 
01763   gcFIXUP(pr->constant_folding);
01764   gcFIXUP(pr->reading_delayed);
01765   
01766   gcFIXUP(pr->overflow_reply);
01767 
01768   gcFIXUP(pr->values_buffer);
01769 
01770   gcFIXUP(pr->tail_buffer);
01771   
01772   gcFIXUP(pr->ku.eval.wait_expr);
01773 
01774   gcFIXUP(pr->ku.apply.tail_rator);
01775   gcFIXUP(pr->ku.apply.tail_rands);
01776 
01777   gcFIXUP(pr->ku.multiple.array);
01778 
01779   gcFIXUP(pr->ku.k.p1);
01780   gcFIXUP(pr->ku.k.p2);
01781   gcFIXUP(pr->ku.k.p3);
01782   gcFIXUP(pr->ku.k.p4);
01783   gcFIXUP(pr->ku.k.p5);
01784   
01785   gcFIXUP(pr->list_stack);
01786   
01787   gcFIXUP(pr->kill_data);
01788   gcFIXUP(pr->private_kill_data);
01789   gcFIXUP(pr->private_kill_next);
01790   
01791   gcFIXUP(pr->user_tls);
01792   gcFIXUP(pr->gmp_tls_data);
01793   
01794   gcFIXUP(pr->mr_hop);
01795   gcFIXUP(pr->mref);
01796   gcFIXUP(pr->extra_mrefs);
01797 
01798   gcFIXUP(pr->name);
01799 
01800   gcFIXUP(pr->transitive_resumes);
01801 
01802   gcFIXUP(pr->suspended_box);
01803   gcFIXUP(pr->resumed_box);
01804   gcFIXUP(pr->dead_box);
01805   gcFIXUP(pr->running_box);
01806 
01807   gcFIXUP(pr->mbox_first);
01808   gcFIXUP(pr->mbox_last);
01809   gcFIXUP(pr->mbox_sema);
01810   return
01811   gcBYTES_TO_WORDS(sizeof(Scheme_Thread));
01812 }
01813 
01814 #define thread_val_IS_ATOMIC 0
01815 #define thread_val_IS_CONST_SIZE 1
01816 
01817 
01818 static int runstack_val_SIZE(void *p) {
01819   long *s = (long *)p;
01820   return
01821   s[1];
01822 }
01823 
01824 static int runstack_val_MARK(void *p) {
01825   long *s = (long *)p;
01826   void **a, **b;
01827   a = (void **)s + 4 + s[2];
01828   b = (void **)s + 4 + s[3];
01829   while (a < b) {
01830     gcMARK(*a);
01831     a++;
01832   }
01833   return
01834   s[1];
01835 }
01836 
01837 static int runstack_val_FIXUP(void *p) {
01838   long *s = (long *)p;
01839   void **a, **b;
01840   a = (void **)s + 4 + s[2];
01841   b = (void **)s + 4 + s[3];
01842   while (a < b) {
01843     gcFIXUP(*a);
01844     a++;
01845   }
01846 
01847   /* Zero out the part that we didn't mark, in case it becomes
01848      live later. */
01849   a = (void **)s + 4;
01850   b = (void **)s + 4 + s[2];
01851   while (a < b) {
01852     *a = RUNSTACK_ZERO_VAL;
01853     a++;
01854   }
01855   a = (void **)s + 4 + s[3];
01856   b = (void **)s + 4 + (s[1] - 4);
01857   while (a < b) {
01858     *a = RUNSTACK_ZERO_VAL;
01859     a++;
01860   }
01861   return
01862   s[1];
01863 }
01864 
01865 #define runstack_val_IS_ATOMIC 0
01866 #define runstack_val_IS_CONST_SIZE 0
01867 
01868 
01869 static int prompt_val_SIZE(void *p) {
01870   return
01871   gcBYTES_TO_WORDS(sizeof(Scheme_Prompt));
01872 }
01873 
01874 static int prompt_val_MARK(void *p) {
01875   Scheme_Prompt *pr = (Scheme_Prompt *)p;
01876   gcMARK(pr->boundary_overflow_id);
01877   if (!GC_merely_accounting())
01878     gcMARK(pr->runstack_boundary_start);
01879   gcMARK(pr->tag);
01880   gcMARK(pr->id);
01881   return
01882   gcBYTES_TO_WORDS(sizeof(Scheme_Prompt));
01883 }
01884 
01885 static int prompt_val_FIXUP(void *p) {
01886   Scheme_Prompt *pr = (Scheme_Prompt *)p;
01887   gcFIXUP(pr->boundary_overflow_id);
01888   if (!GC_merely_accounting())
01889     gcFIXUP(pr->runstack_boundary_start);
01890   gcFIXUP(pr->tag);
01891   gcFIXUP(pr->id);
01892   return
01893   gcBYTES_TO_WORDS(sizeof(Scheme_Prompt));
01894 }
01895 
01896 #define prompt_val_IS_ATOMIC 0
01897 #define prompt_val_IS_CONST_SIZE 1
01898 
01899 
01900 static int cont_mark_set_val_SIZE(void *p) {
01901   return
01902   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set));
01903 }
01904 
01905 static int cont_mark_set_val_MARK(void *p) {
01906   Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p;
01907   gcMARK(s->chain);
01908   gcMARK(s->native_stack_trace);
01909 
01910   return
01911   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set));
01912 }
01913 
01914 static int cont_mark_set_val_FIXUP(void *p) {
01915   Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p;
01916   gcFIXUP(s->chain);
01917   gcFIXUP(s->native_stack_trace);
01918 
01919   return
01920   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set));
01921 }
01922 
01923 #define cont_mark_set_val_IS_ATOMIC 0
01924 #define cont_mark_set_val_IS_CONST_SIZE 1
01925 
01926 
01927 static int sema_val_SIZE(void *p) {
01928   return
01929   gcBYTES_TO_WORDS(sizeof(Scheme_Sema));
01930 }
01931 
01932 static int sema_val_MARK(void *p) {
01933   Scheme_Sema *s = (Scheme_Sema *)p;
01934 
01935   gcMARK(s->first);
01936   gcMARK(s->last);
01937 
01938   return
01939   gcBYTES_TO_WORDS(sizeof(Scheme_Sema));
01940 }
01941 
01942 static int sema_val_FIXUP(void *p) {
01943   Scheme_Sema *s = (Scheme_Sema *)p;
01944 
01945   gcFIXUP(s->first);
01946   gcFIXUP(s->last);
01947 
01948   return
01949   gcBYTES_TO_WORDS(sizeof(Scheme_Sema));
01950 }
01951 
01952 #define sema_val_IS_ATOMIC 0
01953 #define sema_val_IS_CONST_SIZE 1
01954 
01955 
01956 static int channel_val_SIZE(void *p) {
01957   return
01958   gcBYTES_TO_WORDS(sizeof(Scheme_Channel));
01959 }
01960 
01961 static int channel_val_MARK(void *p) {
01962   Scheme_Channel *s = (Scheme_Channel *)p;
01963 
01964   gcMARK(s->get_first);
01965   gcMARK(s->get_last);
01966   gcMARK(s->put_first);
01967   gcMARK(s->put_last);
01968 
01969   return
01970   gcBYTES_TO_WORDS(sizeof(Scheme_Channel));
01971 }
01972 
01973 static int channel_val_FIXUP(void *p) {
01974   Scheme_Channel *s = (Scheme_Channel *)p;
01975 
01976   gcFIXUP(s->get_first);
01977   gcFIXUP(s->get_last);
01978   gcFIXUP(s->put_first);
01979   gcFIXUP(s->put_last);
01980 
01981   return
01982   gcBYTES_TO_WORDS(sizeof(Scheme_Channel));
01983 }
01984 
01985 #define channel_val_IS_ATOMIC 0
01986 #define channel_val_IS_CONST_SIZE 1
01987 
01988 
01989 static int channel_put_val_SIZE(void *p) {
01990   return
01991   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put));
01992 }
01993 
01994 static int channel_put_val_MARK(void *p) {
01995   Scheme_Channel_Put *s = (Scheme_Channel_Put *)p;
01996 
01997   gcMARK(s->ch);
01998   gcMARK(s->val);
01999 
02000   return
02001   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put));
02002 }
02003 
02004 static int channel_put_val_FIXUP(void *p) {
02005   Scheme_Channel_Put *s = (Scheme_Channel_Put *)p;
02006 
02007   gcFIXUP(s->ch);
02008   gcFIXUP(s->val);
02009 
02010   return
02011   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put));
02012 }
02013 
02014 #define channel_put_val_IS_ATOMIC 0
02015 #define channel_put_val_IS_CONST_SIZE 1
02016 
02017 
02018 static int hash_table_val_SIZE(void *p) {
02019   return
02020   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table));
02021 }
02022 
02023 static int hash_table_val_MARK(void *p) {
02024   Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p;
02025 
02026   gcMARK(ht->keys);
02027   gcMARK(ht->vals);
02028   gcMARK(ht->mutex);
02029 
02030   return
02031   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table));
02032 }
02033 
02034 static int hash_table_val_FIXUP(void *p) {
02035   Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p;
02036 
02037   gcFIXUP(ht->keys);
02038   gcFIXUP(ht->vals);
02039   gcFIXUP(ht->mutex);
02040 
02041   return
02042   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table));
02043 }
02044 
02045 #define hash_table_val_IS_ATOMIC 0
02046 #define hash_table_val_IS_CONST_SIZE 1
02047 
02048 
02049 static int bucket_table_val_SIZE(void *p) {
02050   return
02051   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table));
02052 }
02053 
02054 static int bucket_table_val_MARK(void *p) {
02055   Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p;
02056 
02057   gcMARK(ht->buckets);
02058   gcMARK(ht->mutex);
02059 
02060   return
02061   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table));
02062 }
02063 
02064 static int bucket_table_val_FIXUP(void *p) {
02065   Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p;
02066 
02067   gcFIXUP(ht->buckets);
02068   gcFIXUP(ht->mutex);
02069 
02070   return
02071   gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table));
02072 }
02073 
02074 #define bucket_table_val_IS_ATOMIC 0
02075 #define bucket_table_val_IS_CONST_SIZE 1
02076 
02077 
02078 static int namespace_val_SIZE(void *p) {
02079   return
02080   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
02081 }
02082 
02083 static int namespace_val_MARK(void *p) {
02084   Scheme_Env *e = (Scheme_Env *)p;
02085 
02086   gcMARK(e->module);
02087   gcMARK(e->module_registry);
02088   gcMARK(e->export_registry);
02089   gcMARK(e->insp);
02090 
02091   gcMARK(e->rename_set);
02092   gcMARK(e->temp_marked_names);
02093   gcMARK(e->post_ex_rename_set);
02094 
02095   gcMARK(e->syntax);
02096   gcMARK(e->exp_env);
02097   gcMARK(e->template_env);
02098   gcMARK(e->label_env);
02099 
02100   gcMARK(e->shadowed_syntax);
02101 
02102   gcMARK(e->link_midx);
02103   gcMARK(e->require_names);
02104   gcMARK(e->et_require_names);
02105   gcMARK(e->tt_require_names);
02106   gcMARK(e->dt_require_names);
02107   gcMARK(e->other_require_names);
02108   gcMARK(e->did_starts);
02109   gcMARK(e->available_next[0]);
02110   gcMARK(e->available_next[1]);
02111 
02112   gcMARK(e->toplevel);
02113   gcMARK(e->modchain);
02114 
02115   gcMARK(e->modvars);
02116 
02117 
02118   return
02119   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
02120 }
02121 
02122 static int namespace_val_FIXUP(void *p) {
02123   Scheme_Env *e = (Scheme_Env *)p;
02124 
02125   gcFIXUP(e->module);
02126   gcFIXUP(e->module_registry);
02127   gcFIXUP(e->export_registry);
02128   gcFIXUP(e->insp);
02129 
02130   gcFIXUP(e->rename_set);
02131   gcFIXUP(e->temp_marked_names);
02132   gcFIXUP(e->post_ex_rename_set);
02133 
02134   gcFIXUP(e->syntax);
02135   gcFIXUP(e->exp_env);
02136   gcFIXUP(e->template_env);
02137   gcFIXUP(e->label_env);
02138 
02139   gcFIXUP(e->shadowed_syntax);
02140 
02141   gcFIXUP(e->link_midx);
02142   gcFIXUP(e->require_names);
02143   gcFIXUP(e->et_require_names);
02144   gcFIXUP(e->tt_require_names);
02145   gcFIXUP(e->dt_require_names);
02146   gcFIXUP(e->other_require_names);
02147   gcFIXUP(e->did_starts);
02148   gcFIXUP(e->available_next[0]);
02149   gcFIXUP(e->available_next[1]);
02150 
02151   gcFIXUP(e->toplevel);
02152   gcFIXUP(e->modchain);
02153 
02154   gcFIXUP(e->modvars);
02155 
02156 
02157   return
02158   gcBYTES_TO_WORDS(sizeof(Scheme_Env));
02159 }
02160 
02161 #define namespace_val_IS_ATOMIC 0
02162 #define namespace_val_IS_CONST_SIZE 1
02163 
02164 
02165 static int random_state_val_SIZE(void *p) {
02166   return
02167   gcBYTES_TO_WORDS(sizeof(Scheme_Random_State));
02168 }
02169 
02170 static int random_state_val_MARK(void *p) {
02171   return
02172   gcBYTES_TO_WORDS(sizeof(Scheme_Random_State));
02173 }
02174 
02175 static int random_state_val_FIXUP(void *p) {
02176   return
02177   gcBYTES_TO_WORDS(sizeof(Scheme_Random_State));
02178 }
02179 
02180 #define random_state_val_IS_ATOMIC 1
02181 #define random_state_val_IS_CONST_SIZE 1
02182 
02183 
02184 static int compilation_top_val_SIZE(void *p) {
02185   return
02186   gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top));
02187 }
02188 
02189 static int compilation_top_val_MARK(void *p) {
02190   Scheme_Compilation_Top *t = (Scheme_Compilation_Top *)p;
02191   gcMARK(t->code);
02192   gcMARK(t->prefix);
02193 
02194   return
02195   gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top));
02196 }
02197 
02198 static int compilation_top_val_FIXUP(void *p) {
02199   Scheme_Compilation_Top *t = (Scheme_Compilation_Top *)p;
02200   gcFIXUP(t->code);
02201   gcFIXUP(t->prefix);
02202 
02203   return
02204   gcBYTES_TO_WORDS(sizeof(Scheme_Compilation_Top));
02205 }
02206 
02207 #define compilation_top_val_IS_ATOMIC 0
02208 #define compilation_top_val_IS_CONST_SIZE 1
02209 
02210 
02211 static int resolve_prefix_val_SIZE(void *p) {
02212   return
02213   gcBYTES_TO_WORDS(sizeof(Resolve_Prefix));
02214 }
02215 
02216 static int resolve_prefix_val_MARK(void *p) {
02217   Resolve_Prefix *rp = (Resolve_Prefix *)p;
02218   gcMARK(rp->toplevels);
02219   gcMARK(rp->stxes);
02220   gcMARK(rp->delay_info_rpair);
02221 
02222   return
02223   gcBYTES_TO_WORDS(sizeof(Resolve_Prefix));
02224 }
02225 
02226 static int resolve_prefix_val_FIXUP(void *p) {
02227   Resolve_Prefix *rp = (Resolve_Prefix *)p;
02228   gcFIXUP(rp->toplevels);
02229   gcFIXUP(rp->stxes);
02230   gcFIXUP(rp->delay_info_rpair);
02231 
02232   return
02233   gcBYTES_TO_WORDS(sizeof(Resolve_Prefix));
02234 }
02235 
02236 #define resolve_prefix_val_IS_ATOMIC 0
02237 #define resolve_prefix_val_IS_CONST_SIZE 1
02238 
02239 
02240 static int comp_prefix_val_SIZE(void *p) {
02241   return
02242   gcBYTES_TO_WORDS(sizeof(Comp_Prefix));
02243 }
02244 
02245 static int comp_prefix_val_MARK(void *p) {
02246   Comp_Prefix *cp = (Comp_Prefix *)p;
02247   gcMARK(cp->toplevels);
02248   gcMARK(cp->stxes);
02249 
02250   return
02251   gcBYTES_TO_WORDS(sizeof(Comp_Prefix));
02252 }
02253 
02254 static int comp_prefix_val_FIXUP(void *p) {
02255   Comp_Prefix *cp = (Comp_Prefix *)p;
02256   gcFIXUP(cp->toplevels);
02257   gcFIXUP(cp->stxes);
02258 
02259   return
02260   gcBYTES_TO_WORDS(sizeof(Comp_Prefix));
02261 }
02262 
02263 #define comp_prefix_val_IS_ATOMIC 0
02264 #define comp_prefix_val_IS_CONST_SIZE 1
02265 
02266 
02267 static int svector_val_SIZE(void *p) {
02268   return
02269   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
02270 }
02271 
02272 static int svector_val_MARK(void *p) {
02273   Scheme_Object *o = (Scheme_Object *)p;
02274 
02275   gcMARK(SCHEME_SVEC_VEC(o));
02276 
02277   return
02278   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
02279 }
02280 
02281 static int svector_val_FIXUP(void *p) {
02282   Scheme_Object *o = (Scheme_Object *)p;
02283 
02284   gcFIXUP(SCHEME_SVEC_VEC(o));
02285 
02286   return
02287   gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object));
02288 }
02289 
02290 #define svector_val_IS_ATOMIC 0
02291 #define svector_val_IS_CONST_SIZE 1
02292 
02293 
02294 static int stx_val_SIZE(void *p) {
02295   return
02296   gcBYTES_TO_WORDS(sizeof(Scheme_Stx));
02297 }
02298 
02299 static int stx_val_MARK(void *p) {
02300   Scheme_Stx *stx = (Scheme_Stx *)p;
02301   gcMARK(stx->val);
02302   gcMARK(stx->srcloc);
02303   gcMARK(stx->wraps);
02304   gcMARK(stx->certs);
02305   gcMARK(stx->props);
02306   if (!(MZ_OPT_HASH_KEY(&(stx)->iso) & STX_SUBSTX_FLAG))
02307     gcMARK(stx->u.modinfo_cache);
02308   return
02309   gcBYTES_TO_WORDS(sizeof(Scheme_Stx));
02310 }
02311 
02312 static int stx_val_FIXUP(void *p) {
02313   Scheme_Stx *stx = (Scheme_Stx *)p;
02314   gcFIXUP(stx->val);
02315   gcFIXUP(stx->srcloc);
02316   gcFIXUP(stx->wraps);
02317   gcFIXUP(stx->certs);
02318   gcFIXUP(stx->props);
02319   if (!(MZ_OPT_HASH_KEY(&(stx)->iso) & STX_SUBSTX_FLAG))
02320     gcFIXUP(stx->u.modinfo_cache);
02321   return
02322   gcBYTES_TO_WORDS(sizeof(Scheme_Stx));
02323 }
02324 
02325 #define stx_val_IS_ATOMIC 0
02326 #define stx_val_IS_CONST_SIZE 1
02327 
02328 
02329 static int stx_off_val_SIZE(void *p) {
02330   return
02331   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset));
02332 }
02333 
02334 static int stx_off_val_MARK(void *p) {
02335   Scheme_Stx_Offset *o = (Scheme_Stx_Offset *)p;
02336   gcMARK(o->src);
02337   return
02338   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset));
02339 }
02340 
02341 static int stx_off_val_FIXUP(void *p) {
02342   Scheme_Stx_Offset *o = (Scheme_Stx_Offset *)p;
02343   gcFIXUP(o->src);
02344   return
02345   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Offset));
02346 }
02347 
02348 #define stx_off_val_IS_ATOMIC 0
02349 #define stx_off_val_IS_CONST_SIZE 1
02350 
02351 
02352 static int module_val_SIZE(void *p) {
02353   return
02354   gcBYTES_TO_WORDS(sizeof(Scheme_Module));
02355 }
02356 
02357 static int module_val_MARK(void *p) {
02358   Scheme_Module *m = (Scheme_Module *)p;
02359   gcMARK(m->modname);
02360 
02361   gcMARK(m->et_requires);
02362   gcMARK(m->requires);
02363   gcMARK(m->tt_requires);
02364   gcMARK(m->dt_requires);
02365   gcMARK(m->other_requires);
02366 
02367   gcMARK(m->body);
02368   gcMARK(m->et_body);
02369 
02370   gcMARK(m->me);
02371 
02372   gcMARK(m->provide_protects);
02373   gcMARK(m->indirect_provides);
02374 
02375   gcMARK(m->indirect_syntax_provides);
02376 
02377   gcMARK(m->et_provide_protects);
02378   gcMARK(m->et_indirect_provides);
02379 
02380   gcMARK(m->self_modidx);
02381 
02382   gcMARK(m->accessible);
02383   gcMARK(m->et_accessible);
02384 
02385   gcMARK(m->insp);
02386 
02387   gcMARK(m->lang_info);
02388 
02389   gcMARK(m->hints);
02390   gcMARK(m->ii_src);
02391 
02392   gcMARK(m->comp_prefix);
02393   gcMARK(m->prefix);
02394   gcMARK(m->dummy);
02395 
02396   gcMARK(m->rn_stx);
02397 
02398   gcMARK(m->primitive);
02399   return
02400   gcBYTES_TO_WORDS(sizeof(Scheme_Module));
02401 }
02402 
02403 static int module_val_FIXUP(void *p) {
02404   Scheme_Module *m = (Scheme_Module *)p;
02405   gcFIXUP(m->modname);
02406 
02407   gcFIXUP(m->et_requires);
02408   gcFIXUP(m->requires);
02409   gcFIXUP(m->tt_requires);
02410   gcFIXUP(m->dt_requires);
02411   gcFIXUP(m->other_requires);
02412 
02413   gcFIXUP(m->body);
02414   gcFIXUP(m->et_body);
02415 
02416   gcFIXUP(m->me);
02417 
02418   gcFIXUP(m->provide_protects);
02419   gcFIXUP(m->indirect_provides);
02420 
02421   gcFIXUP(m->indirect_syntax_provides);
02422 
02423   gcFIXUP(m->et_provide_protects);
02424   gcFIXUP(m->et_indirect_provides);
02425 
02426   gcFIXUP(m->self_modidx);
02427 
02428   gcFIXUP(m->accessible);
02429   gcFIXUP(m->et_accessible);
02430 
02431   gcFIXUP(m->insp);
02432 
02433   gcFIXUP(m->lang_info);
02434 
02435   gcFIXUP(m->hints);
02436   gcFIXUP(m->ii_src);
02437 
02438   gcFIXUP(m->comp_prefix);
02439   gcFIXUP(m->prefix);
02440   gcFIXUP(m->dummy);
02441 
02442   gcFIXUP(m->rn_stx);
02443 
02444   gcFIXUP(m->primitive);
02445   return
02446   gcBYTES_TO_WORDS(sizeof(Scheme_Module));
02447 }
02448 
02449 #define module_val_IS_ATOMIC 0
02450 #define module_val_IS_CONST_SIZE 1
02451 
02452 
02453 static int module_phase_exports_val_SIZE(void *p) {
02454   return
02455   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports));
02456 }
02457 
02458 static int module_phase_exports_val_MARK(void *p) {
02459   Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p;
02460 
02461   gcMARK(m->phase_index);
02462 
02463   gcMARK(m->src_modidx);
02464 
02465   gcMARK(m->provides);
02466   gcMARK(m->provide_srcs);
02467   gcMARK(m->provide_src_names);
02468   gcMARK(m->provide_nominal_srcs);
02469   gcMARK(m->provide_src_phases);
02470   gcMARK(m->provide_insps);
02471 
02472   gcMARK(m->kernel_exclusion);
02473   gcMARK(m->kernel_exclusion2);
02474 
02475   gcMARK(m->ht);
02476 
02477   return
02478   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports));
02479 }
02480 
02481 static int module_phase_exports_val_FIXUP(void *p) {
02482   Scheme_Module_Phase_Exports *m = (Scheme_Module_Phase_Exports *)p;
02483 
02484   gcFIXUP(m->phase_index);
02485 
02486   gcFIXUP(m->src_modidx);
02487 
02488   gcFIXUP(m->provides);
02489   gcFIXUP(m->provide_srcs);
02490   gcFIXUP(m->provide_src_names);
02491   gcFIXUP(m->provide_nominal_srcs);
02492   gcFIXUP(m->provide_src_phases);
02493   gcFIXUP(m->provide_insps);
02494 
02495   gcFIXUP(m->kernel_exclusion);
02496   gcFIXUP(m->kernel_exclusion2);
02497 
02498   gcFIXUP(m->ht);
02499 
02500   return
02501   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Phase_Exports));
02502 }
02503 
02504 #define module_phase_exports_val_IS_ATOMIC 0
02505 #define module_phase_exports_val_IS_CONST_SIZE 1
02506 
02507 
02508 static int module_exports_val_SIZE(void *p) {
02509   return
02510   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports));
02511 }
02512 
02513 static int module_exports_val_MARK(void *p) {
02514   Scheme_Module_Exports *m = (Scheme_Module_Exports *)p;
02515 
02516   gcMARK(m->rt);
02517   gcMARK(m->et);
02518   gcMARK(m->dt);
02519   gcMARK(m->other_phases);
02520 
02521   gcMARK(m->src_modidx);
02522   return
02523   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports));
02524 }
02525 
02526 static int module_exports_val_FIXUP(void *p) {
02527   Scheme_Module_Exports *m = (Scheme_Module_Exports *)p;
02528 
02529   gcFIXUP(m->rt);
02530   gcFIXUP(m->et);
02531   gcFIXUP(m->dt);
02532   gcFIXUP(m->other_phases);
02533 
02534   gcFIXUP(m->src_modidx);
02535   return
02536   gcBYTES_TO_WORDS(sizeof(Scheme_Module_Exports));
02537 }
02538 
02539 #define module_exports_val_IS_ATOMIC 0
02540 #define module_exports_val_IS_CONST_SIZE 1
02541 
02542 
02543 static int modidx_val_SIZE(void *p) {
02544   return
02545   gcBYTES_TO_WORDS(sizeof(Scheme_Modidx));
02546 }
02547 
02548 static int modidx_val_MARK(void *p) {
02549   Scheme_Modidx *modidx = (Scheme_Modidx *)p;
02550 
02551   gcMARK(modidx->path);
02552   gcMARK(modidx->base);
02553   gcMARK(modidx->resolved);
02554   gcMARK(modidx->shift_cache);
02555   gcMARK(modidx->cache_next);
02556   return
02557   gcBYTES_TO_WORDS(sizeof(Scheme_Modidx));
02558 }
02559 
02560 static int modidx_val_FIXUP(void *p) {
02561   Scheme_Modidx *modidx = (Scheme_Modidx *)p;
02562 
02563   gcFIXUP(modidx->path);
02564   gcFIXUP(modidx->base);
02565   gcFIXUP(modidx->resolved);
02566   gcFIXUP(modidx->shift_cache);
02567   gcFIXUP(modidx->cache_next);
02568   return
02569   gcBYTES_TO_WORDS(sizeof(Scheme_Modidx));
02570 }
02571 
02572 #define modidx_val_IS_ATOMIC 0
02573 #define modidx_val_IS_CONST_SIZE 1
02574 
02575 
02576 static int guard_val_SIZE(void *p) {
02577   return
02578   gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard));
02579 }
02580 
02581 static int guard_val_MARK(void *p) {
02582   Scheme_Security_Guard *g = (Scheme_Security_Guard *)p;
02583 
02584   gcMARK(g->parent);
02585   gcMARK(g->file_proc);
02586   gcMARK(g->network_proc);
02587   gcMARK(g->link_proc);
02588   return
02589   gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard));
02590 }
02591 
02592 static int guard_val_FIXUP(void *p) {
02593   Scheme_Security_Guard *g = (Scheme_Security_Guard *)p;
02594 
02595   gcFIXUP(g->parent);
02596   gcFIXUP(g->file_proc);
02597   gcFIXUP(g->network_proc);
02598   gcFIXUP(g->link_proc);
02599   return
02600   gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard));
02601 }
02602 
02603 #define guard_val_IS_ATOMIC 0
02604 #define guard_val_IS_CONST_SIZE 1
02605 
02606 
02607 static int buf_holder_SIZE(void *p) {
02608   return
02609   gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder));
02610 }
02611 
02612 static int buf_holder_MARK(void *p) {
02613   Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p;
02614  
02615   MARK_jmpup(&h->buf);
02616 
02617   return
02618   gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder));
02619 }
02620 
02621 static int buf_holder_FIXUP(void *p) {
02622   Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p;
02623  
02624   FIXUP_jmpup(&h->buf);
02625 
02626   return
02627   gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder));
02628 }
02629 
02630 #define buf_holder_IS_ATOMIC 0
02631 #define buf_holder_IS_CONST_SIZE 1
02632 
02633 
02634 static int mark_inspector_SIZE(void *p) {
02635   return
02636   gcBYTES_TO_WORDS(sizeof(Scheme_Inspector));
02637 }
02638 
02639 static int mark_inspector_MARK(void *p) {
02640   Scheme_Inspector *i = (Scheme_Inspector *)p;
02641   gcMARK(i->superior);
02642   return
02643   gcBYTES_TO_WORDS(sizeof(Scheme_Inspector));
02644 }
02645 
02646 static int mark_inspector_FIXUP(void *p) {
02647   Scheme_Inspector *i = (Scheme_Inspector *)p;
02648   gcFIXUP(i->superior);
02649   return
02650   gcBYTES_TO_WORDS(sizeof(Scheme_Inspector));
02651 }
02652 
02653 #define mark_inspector_IS_ATOMIC 0
02654 #define mark_inspector_IS_CONST_SIZE 1
02655 
02656 
02657 static int mark_pipe_SIZE(void *p) {
02658   return
02659   gcBYTES_TO_WORDS(sizeof(Scheme_Pipe));
02660 }
02661 
02662 static int mark_pipe_MARK(void *p) {
02663   Scheme_Pipe *pp = (Scheme_Pipe *)p;
02664     
02665   gcMARK(pp->buf);
02666   gcMARK(pp->wakeup_on_read);
02667   gcMARK(pp->wakeup_on_write);
02668 
02669   return
02670   gcBYTES_TO_WORDS(sizeof(Scheme_Pipe));
02671 }
02672 
02673 static int mark_pipe_FIXUP(void *p) {
02674   Scheme_Pipe *pp = (Scheme_Pipe *)p;
02675     
02676   gcFIXUP(pp->buf);
02677   gcFIXUP(pp->wakeup_on_read);
02678   gcFIXUP(pp->wakeup_on_write);
02679 
02680   return
02681   gcBYTES_TO_WORDS(sizeof(Scheme_Pipe));
02682 }
02683 
02684 #define mark_pipe_IS_ATOMIC 0
02685 #define mark_pipe_IS_CONST_SIZE 1
02686 
02687 
02688 static int mark_logger_SIZE(void *p) {
02689   return
02690   gcBYTES_TO_WORDS(sizeof(Scheme_Logger));
02691 }
02692 
02693 static int mark_logger_MARK(void *p) {
02694   Scheme_Logger *l = (Scheme_Logger *)p;
02695   gcMARK(l->name);
02696   gcMARK(l->parent);
02697   gcMARK(l->readers);
02698   gcMARK(l->timestamp);
02699   return
02700   gcBYTES_TO_WORDS(sizeof(Scheme_Logger));
02701 }
02702 
02703 static int mark_logger_FIXUP(void *p) {
02704   Scheme_Logger *l = (Scheme_Logger *)p;
02705   gcFIXUP(l->name);
02706   gcFIXUP(l->parent);
02707   gcFIXUP(l->readers);
02708   gcFIXUP(l->timestamp);
02709   return
02710   gcBYTES_TO_WORDS(sizeof(Scheme_Logger));
02711 }
02712 
02713 #define mark_logger_IS_ATOMIC 0
02714 #define mark_logger_IS_CONST_SIZE 1
02715 
02716 
02717 static int mark_log_reader_SIZE(void *p) {
02718   return
02719   gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader));
02720 }
02721 
02722 static int mark_log_reader_MARK(void *p) {
02723   Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p;
02724   gcMARK(lr->sema);
02725   gcMARK(lr->head);
02726   gcMARK(lr->tail);
02727   return
02728   gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader));
02729 }
02730 
02731 static int mark_log_reader_FIXUP(void *p) {
02732   Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p;
02733   gcFIXUP(lr->sema);
02734   gcFIXUP(lr->head);
02735   gcFIXUP(lr->tail);
02736   return
02737   gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader));
02738 }
02739 
02740 #define mark_log_reader_IS_ATOMIC 0
02741 #define mark_log_reader_IS_CONST_SIZE 1
02742 
02743 
02744 #endif  /* TYPE */
02745 
02746 /**********************************************************************/
02747 
02748 #ifdef MARKS_FOR_ENGINE_C
02749 
02750 static int engine_val_SIZE(void *p) {
02751   return
02752   gcBYTES_TO_WORDS(sizeof(Scheme_Engine));
02753 }
02754 
02755 static int engine_val_MARK(void *p) {
02756   Scheme_Engine *en = (Scheme_Engine *)p;
02757   return
02758   gcBYTES_TO_WORDS(sizeof(Scheme_Engine));
02759 }
02760 
02761 static int engine_val_FIXUP(void *p) {
02762   Scheme_Engine *en = (Scheme_Engine *)p;
02763   return
02764   gcBYTES_TO_WORDS(sizeof(Scheme_Engine));
02765 }
02766 
02767 #define engine_val_IS_ATOMIC 0
02768 #define engine_val_IS_CONST_SIZE 1
02769 
02770 
02771 #endif  /* ENGINE */
02772 
02773 #ifdef MARKS_FOR_ENV_C
02774 
02775 static int mark_comp_env_SIZE(void *p) {
02776   return
02777   gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
02778 }
02779 
02780 static int mark_comp_env_MARK(void *p) {
02781   Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p;
02782 
02783   gcMARK(e->base.genv);
02784   gcMARK(e->base.insp);
02785   gcMARK(e->base.prefix);
02786   gcMARK(e->base.next);
02787   gcMARK(e->base.values);
02788   gcMARK(e->base.certs);
02789   gcMARK(e->base.renames);
02790   gcMARK(e->base.uid);
02791   gcMARK(e->base.uids);
02792   gcMARK(e->base.dup_check);
02793   gcMARK(e->base.intdef_name);
02794   gcMARK(e->base.in_modidx);
02795   gcMARK(e->base.skip_table);
02796   
02797   gcMARK(e->data.const_names);
02798   gcMARK(e->data.const_vals);
02799   gcMARK(e->data.const_uids);
02800   gcMARK(e->data.sealed);
02801   gcMARK(e->data.use);
02802   gcMARK(e->data.lifts);
02803 
02804   return
02805   gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
02806 }
02807 
02808 static int mark_comp_env_FIXUP(void *p) {
02809   Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p;
02810 
02811   gcFIXUP(e->base.genv);
02812   gcFIXUP(e->base.insp);
02813   gcFIXUP(e->base.prefix);
02814   gcFIXUP(e->base.next);
02815   gcFIXUP(e->base.values);
02816   gcFIXUP(e->base.certs);
02817   gcFIXUP(e->base.renames);
02818   gcFIXUP(e->base.uid);
02819   gcFIXUP(e->base.uids);
02820   gcFIXUP(e->base.dup_check);
02821   gcFIXUP(e->base.intdef_name);
02822   gcFIXUP(e->base.in_modidx);
02823   gcFIXUP(e->base.skip_table);
02824   
02825   gcFIXUP(e->data.const_names);
02826   gcFIXUP(e->data.const_vals);
02827   gcFIXUP(e->data.const_uids);
02828   gcFIXUP(e->data.sealed);
02829   gcFIXUP(e->data.use);
02830   gcFIXUP(e->data.lifts);
02831 
02832   return
02833   gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
02834 }
02835 
02836 #define mark_comp_env_IS_ATOMIC 0
02837 #define mark_comp_env_IS_CONST_SIZE 1
02838 
02839 
02840 static int mark_resolve_info_SIZE(void *p) {
02841   return
02842   gcBYTES_TO_WORDS(sizeof(Resolve_Info));
02843 }
02844 
02845 static int mark_resolve_info_MARK(void *p) {
02846   Resolve_Info *i = (Resolve_Info *)p;
02847   
02848   gcMARK(i->prefix);
02849   gcMARK(i->stx_map);
02850   gcMARK(i->old_pos);
02851   gcMARK(i->new_pos);
02852   gcMARK(i->old_stx_pos);
02853   gcMARK(i->flags);
02854   gcMARK(i->lifts);
02855   gcMARK(i->lifted);
02856   gcMARK(i->next);
02857 
02858   return
02859   gcBYTES_TO_WORDS(sizeof(Resolve_Info));
02860 }
02861 
02862 static int mark_resolve_info_FIXUP(void *p) {
02863   Resolve_Info *i = (Resolve_Info *)p;
02864   
02865   gcFIXUP(i->prefix);
02866   gcFIXUP(i->stx_map);
02867   gcFIXUP(i->old_pos);
02868   gcFIXUP(i->new_pos);
02869   gcFIXUP(i->old_stx_pos);
02870   gcFIXUP(i->flags);
02871   gcFIXUP(i->lifts);
02872   gcFIXUP(i->lifted);
02873   gcFIXUP(i->next);
02874 
02875   return
02876   gcBYTES_TO_WORDS(sizeof(Resolve_Info));
02877 }
02878 
02879 #define mark_resolve_info_IS_ATOMIC 0
02880 #define mark_resolve_info_IS_CONST_SIZE 1
02881 
02882 
02883 static int mark_optimize_info_SIZE(void *p) {
02884   return
02885   gcBYTES_TO_WORDS(sizeof(Optimize_Info));
02886 }
02887 
02888 static int mark_optimize_info_MARK(void *p) {
02889   Optimize_Info *i = (Optimize_Info *)p;
02890   
02891   gcMARK(i->stat_dists);
02892   gcMARK(i->sd_depths);
02893   gcMARK(i->next);
02894   gcMARK(i->use);
02895   gcMARK(i->consts);
02896   gcMARK(i->top_level_consts);
02897   gcMARK(i->transitive_use);
02898   gcMARK(i->transitive_use_len);
02899   gcMARK(i->context);
02900 
02901   return
02902   gcBYTES_TO_WORDS(sizeof(Optimize_Info));
02903 }
02904 
02905 static int mark_optimize_info_FIXUP(void *p) {
02906   Optimize_Info *i = (Optimize_Info *)p;
02907   
02908   gcFIXUP(i->stat_dists);
02909   gcFIXUP(i->sd_depths);
02910   gcFIXUP(i->next);
02911   gcFIXUP(i->use);
02912   gcFIXUP(i->consts);
02913   gcFIXUP(i->top_level_consts);
02914   gcFIXUP(i->transitive_use);
02915   gcFIXUP(i->transitive_use_len);
02916   gcFIXUP(i->context);
02917 
02918   return
02919   gcBYTES_TO_WORDS(sizeof(Optimize_Info));
02920 }
02921 
02922 #define mark_optimize_info_IS_ATOMIC 0
02923 #define mark_optimize_info_IS_CONST_SIZE 1
02924 
02925 
02926 static int mark_sfs_info_SIZE(void *p) {
02927   return
02928   gcBYTES_TO_WORDS(sizeof(SFS_Info));
02929 }
02930 
02931 static int mark_sfs_info_MARK(void *p) {
02932   SFS_Info *i = (SFS_Info *)p;
02933   
02934   gcMARK(i->max_used);
02935   gcMARK(i->max_calls);
02936   gcMARK(i->saved);
02937 
02938   return
02939   gcBYTES_TO_WORDS(sizeof(SFS_Info));
02940 }
02941 
02942 static int mark_sfs_info_FIXUP(void *p) {
02943   SFS_Info *i = (SFS_Info *)p;
02944   
02945   gcFIXUP(i->max_used);
02946   gcFIXUP(i->max_calls);
02947   gcFIXUP(i->saved);
02948 
02949   return
02950   gcBYTES_TO_WORDS(sizeof(SFS_Info));
02951 }
02952 
02953 #define mark_sfs_info_IS_ATOMIC 0
02954 #define mark_sfs_info_IS_CONST_SIZE 1
02955 
02956 
02957 #endif  /* ENV */
02958 
02959 /**********************************************************************/
02960 
02961 #ifdef MARKS_FOR_EVAL_C
02962 
02963 static int mark_comp_info_SIZE(void *p) {
02964   return
02965   gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
02966 }
02967 
02968 static int mark_comp_info_MARK(void *p) {
02969   Scheme_Compile_Info *i = (Scheme_Compile_Info *)p;
02970   
02971   gcMARK(i->value_name);
02972   gcMARK(i->certs);
02973   gcMARK(i->observer);
02974 
02975   return
02976   gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
02977 }
02978 
02979 static int mark_comp_info_FIXUP(void *p) {
02980   Scheme_Compile_Info *i = (Scheme_Compile_Info *)p;
02981   
02982   gcFIXUP(i->value_name);
02983   gcFIXUP(i->certs);
02984   gcFIXUP(i->observer);
02985 
02986   return
02987   gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
02988 }
02989 
02990 #define mark_comp_info_IS_ATOMIC 0
02991 #define mark_comp_info_IS_CONST_SIZE 1
02992 
02993 
02994 static int mark_saved_stack_SIZE(void *p) {
02995   return
02996   gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
02997 }
02998 
02999 static int mark_saved_stack_MARK(void *p) {
03000   Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
03001   
03002   gcMARK(saved->prev);
03003   gcMARK(saved->runstack_start);
03004 
03005   return
03006   gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
03007 }
03008 
03009 static int mark_saved_stack_FIXUP(void *p) {
03010   Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
03011   
03012   gcFIXUP(saved->prev);
03013   gcFIXUP(saved->runstack_start);
03014 
03015   return
03016   gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
03017 }
03018 
03019 #define mark_saved_stack_IS_ATOMIC 0
03020 #define mark_saved_stack_IS_CONST_SIZE 1
03021 
03022 
03023 static int mark_validate_clearing_SIZE(void *p) {
03024   return
03025   gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
03026 }
03027 
03028 static int mark_validate_clearing_MARK(void *p) {
03029   Validate_Clearing *vc = (Validate_Clearing *)p;
03030   
03031   gcMARK(vc->stack);
03032   gcMARK(vc->ncstack);
03033 
03034   return
03035   gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
03036 }
03037 
03038 static int mark_validate_clearing_FIXUP(void *p) {
03039   Validate_Clearing *vc = (Validate_Clearing *)p;
03040   
03041   gcFIXUP(vc->stack);
03042   gcFIXUP(vc->ncstack);
03043 
03044   return
03045   gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
03046 }
03047 
03048 #define mark_validate_clearing_IS_ATOMIC 0
03049 #define mark_validate_clearing_IS_CONST_SIZE 1
03050 
03051 
03052 #endif  /* EVAL */
03053 
03054 /**********************************************************************/
03055 
03056 #ifdef MARKS_FOR_FILE_C
03057 
03058 static int mark_reply_item_SIZE(void *p) {
03059   return
03060   gcBYTES_TO_WORDS(sizeof(ReplyItem));
03061 }
03062 
03063 static int mark_reply_item_MARK(void *p) {
03064   ReplyItem *r = (ReplyItem *)p;
03065   
03066   gcMARK(r->next);
03067 
03068   return
03069   gcBYTES_TO_WORDS(sizeof(ReplyItem));
03070 }
03071 
03072 static int mark_reply_item_FIXUP(void *p) {
03073   ReplyItem *r = (ReplyItem *)p;
03074   
03075   gcFIXUP(r->next);
03076 
03077   return
03078   gcBYTES_TO_WORDS(sizeof(ReplyItem));
03079 }
03080 
03081 #define mark_reply_item_IS_ATOMIC 0
03082 #define mark_reply_item_IS_CONST_SIZE 1
03083 
03084 
03085 #endif  /* FILE */
03086 
03087 /**********************************************************************/
03088 
03089 #ifdef MARKS_FOR_FUN_C
03090 
03091 static int mark_closure_info_SIZE(void *p) {
03092   return
03093   gcBYTES_TO_WORDS(sizeof(Closure_Info));
03094 }
03095 
03096 static int mark_closure_info_MARK(void *p) {
03097   Closure_Info *i = (Closure_Info *)p;
03098   
03099   gcMARK(i->local_flags);
03100   gcMARK(i->base_closure_map);
03101 
03102   return
03103   gcBYTES_TO_WORDS(sizeof(Closure_Info));
03104 }
03105 
03106 static int mark_closure_info_FIXUP(void *p) {
03107   Closure_Info *i = (Closure_Info *)p;
03108   
03109   gcFIXUP(i->local_flags);
03110   gcFIXUP(i->base_closure_map);
03111 
03112   return
03113   gcBYTES_TO_WORDS(sizeof(Closure_Info));
03114 }
03115 
03116 #define mark_closure_info_IS_ATOMIC 0
03117 #define mark_closure_info_IS_CONST_SIZE 1
03118 
03119 
03120 static int mark_dyn_wind_cell_SIZE(void *p) {
03121   return
03122   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
03123 }
03124 
03125 static int mark_dyn_wind_cell_MARK(void *p) {
03126   Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
03127   
03128   gcMARK(l->dw);
03129   gcMARK(l->next);
03130   
03131   return
03132   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
03133 }
03134 
03135 static int mark_dyn_wind_cell_FIXUP(void *p) {
03136   Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
03137   
03138   gcFIXUP(l->dw);
03139   gcFIXUP(l->next);
03140   
03141   return
03142   gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
03143 }
03144 
03145 #define mark_dyn_wind_cell_IS_ATOMIC 0
03146 #define mark_dyn_wind_cell_IS_CONST_SIZE 1
03147 
03148 
03149 static int mark_dyn_wind_info_SIZE(void *p) {
03150   return
03151    gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
03152 }
03153 
03154 static int mark_dyn_wind_info_MARK(void *p) {
03155   Dyn_Wind *d = (Dyn_Wind *)p;
03156   
03157   gcMARK(d->pre);
03158   gcMARK(d->act);
03159   gcMARK(d->post);
03160 
03161   return
03162    gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
03163 }
03164 
03165 static int mark_dyn_wind_info_FIXUP(void *p) {
03166   Dyn_Wind *d = (Dyn_Wind *)p;
03167   
03168   gcFIXUP(d->pre);
03169   gcFIXUP(d->act);
03170   gcFIXUP(d->post);
03171 
03172   return
03173    gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
03174 }
03175 
03176 #define mark_dyn_wind_info_IS_ATOMIC 0
03177 #define mark_dyn_wind_info_IS_CONST_SIZE 1
03178 
03179 
03180 static int mark_cont_mark_chain_SIZE(void *p) {
03181   return
03182   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
03183 }
03184 
03185 static int mark_cont_mark_chain_MARK(void *p) {
03186   Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
03187   
03188   gcMARK(c->key);
03189   gcMARK(c->val);
03190   gcMARK(c->next);
03191 
03192   return
03193   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
03194 }
03195 
03196 static int mark_cont_mark_chain_FIXUP(void *p) {
03197   Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
03198   
03199   gcFIXUP(c->key);
03200   gcFIXUP(c->val);
03201   gcFIXUP(c->next);
03202 
03203   return
03204   gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
03205 }
03206 
03207 #define mark_cont_mark_chain_IS_ATOMIC 0
03208 #define mark_cont_mark_chain_IS_CONST_SIZE 1
03209 
03210 
03211 #endif  /* FUN */
03212 
03213 /**********************************************************************/
03214 
03215 #ifdef MARKS_FOR_HASH_C
03216 
03217 static int hash_tree_val_SIZE(void *p) {
03218   return
03219   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
03220 }
03221 
03222 static int hash_tree_val_MARK(void *p) {
03223   Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
03224 
03225   gcMARK(ht->root);
03226   gcMARK(ht->elems_box);
03227 
03228   return
03229   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
03230 }
03231 
03232 static int hash_tree_val_FIXUP(void *p) {
03233   Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
03234 
03235   gcFIXUP(ht->root);
03236   gcFIXUP(ht->elems_box);
03237 
03238   return
03239   gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
03240 }
03241 
03242 #define hash_tree_val_IS_ATOMIC 0
03243 #define hash_tree_val_IS_CONST_SIZE 1
03244 
03245 
03246 static int mark_rb_node_SIZE(void *p) {
03247   return
03248   gcBYTES_TO_WORDS(sizeof(RBNode));
03249 }
03250 
03251 static int mark_rb_node_MARK(void *p) {
03252   RBNode *rb = (RBNode *)p;
03253 
03254   /* Short-circuit on NULL pointers, which are especially likely */
03255   if (rb->left) {
03256     gcMARK(rb->left);
03257   }
03258   if (rb->right) {
03259     gcMARK(rb->right);
03260   }
03261   gcMARK(rb->key);
03262   gcMARK(rb->val);
03263 
03264   return
03265   gcBYTES_TO_WORDS(sizeof(RBNode));
03266 }
03267 
03268 static int mark_rb_node_FIXUP(void *p) {
03269   RBNode *rb = (RBNode *)p;
03270 
03271   /* Short-circuit on NULL pointers, which are especially likely */
03272   if (rb->left) {
03273     gcFIXUP(rb->left);
03274   }
03275   if (rb->right) {
03276     gcFIXUP(rb->right);
03277   }
03278   gcFIXUP(rb->key);
03279   gcFIXUP(rb->val);
03280 
03281   return
03282   gcBYTES_TO_WORDS(sizeof(RBNode));
03283 }
03284 
03285 #define mark_rb_node_IS_ATOMIC 0
03286 #define mark_rb_node_IS_CONST_SIZE 1
03287 
03288 
03289 #endif  /* HASH */
03290 
03291 /**********************************************************************/
03292 
03293 #ifdef MARKS_FOR_PLACES_C
03294 
03295 static int place_val_SIZE(void *p) {
03296   return
03297   gcBYTES_TO_WORDS(sizeof(Scheme_Place));
03298 }
03299 
03300 static int place_val_MARK(void *p) {
03301   Scheme_Place *pr = (Scheme_Place *)p;
03302   return
03303   gcBYTES_TO_WORDS(sizeof(Scheme_Place));
03304 }
03305 
03306 static int place_val_FIXUP(void *p) {
03307   Scheme_Place *pr = (Scheme_Place *)p;
03308   return
03309   gcBYTES_TO_WORDS(sizeof(Scheme_Place));
03310 }
03311 
03312 #define place_val_IS_ATOMIC 0
03313 #define place_val_IS_CONST_SIZE 1
03314 
03315 
03316 #endif  /* PLACES */
03317 
03318 /**********************************************************************/
03319 
03320 #ifdef MARKS_FOR_PORTFUN_C
03321 
03322 static int mark_load_handler_data_SIZE(void *p) {
03323   return
03324   gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
03325 }
03326 
03327 static int mark_load_handler_data_MARK(void *p) {
03328   LoadHandlerData *d = (LoadHandlerData *)p;
03329     
03330   gcMARK(d->config);
03331   gcMARK(d->port);
03332   gcMARK(d->p);
03333   gcMARK(d->stxsrc);
03334   gcMARK(d->expected_module);
03335   gcMARK(d->delay_load_info);
03336   
03337   return
03338   gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
03339 }
03340 
03341 static int mark_load_handler_data_FIXUP(void *p) {
03342   LoadHandlerData *d = (LoadHandlerData *)p;
03343     
03344   gcFIXUP(d->config);
03345   gcFIXUP(d->port);
03346   gcFIXUP(d->p);
03347   gcFIXUP(d->stxsrc);
03348   gcFIXUP(d->expected_module);
03349   gcFIXUP(d->delay_load_info);
03350   
03351   return
03352   gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
03353 }
03354 
03355 #define mark_load_handler_data_IS_ATOMIC 0
03356 #define mark_load_handler_data_IS_CONST_SIZE 1
03357 
03358 
03359 static int mark_indexed_string_SIZE(void *p) {
03360   return
03361   gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
03362 }
03363 
03364 static int mark_indexed_string_MARK(void *p) {
03365   Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
03366     
03367   gcMARK(is->string);
03368 
03369   return
03370   gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
03371 }
03372 
03373 static int mark_indexed_string_FIXUP(void *p) {
03374   Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
03375     
03376   gcFIXUP(is->string);
03377 
03378   return
03379   gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
03380 }
03381 
03382 #define mark_indexed_string_IS_ATOMIC 0
03383 #define mark_indexed_string_IS_CONST_SIZE 1
03384 
03385 
03386 static int mark_user_input_SIZE(void *p) {
03387   return
03388   gcBYTES_TO_WORDS(sizeof(User_Input_Port));
03389 }
03390 
03391 static int mark_user_input_MARK(void *p) {
03392   User_Input_Port *uip = (User_Input_Port *)p;
03393 
03394   gcMARK(uip->read_proc);
03395   gcMARK(uip->peek_proc);
03396   gcMARK(uip->progress_evt_proc);
03397   gcMARK(uip->peeked_read_proc);
03398   gcMARK(uip->location_proc);
03399   gcMARK(uip->count_lines_proc);
03400   gcMARK(uip->buffer_mode_proc);
03401   gcMARK(uip->close_proc);
03402   gcMARK(uip->reuse_str);
03403   gcMARK(uip->peeked);
03404   gcMARK(uip->prefix_pipe);
03405   return
03406   gcBYTES_TO_WORDS(sizeof(User_Input_Port));
03407 }
03408 
03409 static int mark_user_input_FIXUP(void *p) {
03410   User_Input_Port *uip = (User_Input_Port *)p;
03411 
03412   gcFIXUP(uip->read_proc);
03413   gcFIXUP(uip->peek_proc);
03414   gcFIXUP(uip->progress_evt_proc);
03415   gcFIXUP(uip->peeked_read_proc);
03416   gcFIXUP(uip->location_proc);
03417   gcFIXUP(uip->count_lines_proc);
03418   gcFIXUP(uip->buffer_mode_proc);
03419   gcFIXUP(uip->close_proc);
03420   gcFIXUP(uip->reuse_str);
03421   gcFIXUP(uip->peeked);
03422   gcFIXUP(uip->prefix_pipe);
03423   return
03424   gcBYTES_TO_WORDS(sizeof(User_Input_Port));
03425 }
03426 
03427 #define mark_user_input_IS_ATOMIC 0
03428 #define mark_user_input_IS_CONST_SIZE 1
03429 
03430 
03431 static int mark_user_output_SIZE(void *p) {
03432   return
03433   gcBYTES_TO_WORDS(sizeof(User_Output_Port));
03434 }
03435 
03436 static int mark_user_output_MARK(void *p) {
03437   User_Output_Port *uop = (User_Output_Port *)p;
03438 
03439   gcMARK(uop->evt);
03440   gcMARK(uop->write_evt_proc);
03441   gcMARK(uop->write_proc);
03442   gcMARK(uop->write_special_evt_proc);
03443   gcMARK(uop->write_special_proc);
03444   gcMARK(uop->location_proc);
03445   gcMARK(uop->count_lines_proc);
03446   gcMARK(uop->buffer_mode_proc);
03447   gcMARK(uop->close_proc);
03448   gcMARK(uop->buffer_pipe);
03449   return
03450   gcBYTES_TO_WORDS(sizeof(User_Output_Port));
03451 }
03452 
03453 static int mark_user_output_FIXUP(void *p) {
03454   User_Output_Port *uop = (User_Output_Port *)p;
03455 
03456   gcFIXUP(uop->evt);
03457   gcFIXUP(uop->write_evt_proc);
03458   gcFIXUP(uop->write_proc);
03459   gcFIXUP(uop->write_special_evt_proc);
03460   gcFIXUP(uop->write_special_proc);
03461   gcFIXUP(uop->location_proc);
03462   gcFIXUP(uop->count_lines_proc);
03463   gcFIXUP(uop->buffer_mode_proc);
03464   gcFIXUP(uop->close_proc);
03465   gcFIXUP(uop->buffer_pipe);
03466   return
03467   gcBYTES_TO_WORDS(sizeof(User_Output_Port));
03468 }
03469 
03470 #define mark_user_output_IS_ATOMIC 0
03471 #define mark_user_output_IS_CONST_SIZE 1
03472 
03473 
03474 #endif  /* PORTFUN */
03475 
03476 /**********************************************************************/
03477 
03478 #ifdef MARKS_FOR_PORT_C
03479 
03480 #ifdef WINDOWS_PROCESSES
03481 static int mark_thread_memory_SIZE(void *p) {
03482   return
03483   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
03484 }
03485 
03486 static int mark_thread_memory_MARK(void *p) {
03487   Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p;
03488   gcMARK(tm->prev);
03489   gcMARK(tm->next);
03490 
03491   return
03492   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
03493 }
03494 
03495 static int mark_thread_memory_FIXUP(void *p) {
03496   Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p;
03497   gcFIXUP(tm->prev);
03498   gcFIXUP(tm->next);
03499 
03500   return
03501   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
03502 }
03503 
03504 #define mark_thread_memory_IS_ATOMIC 0
03505 #define mark_thread_memory_IS_CONST_SIZE 1
03506 
03507 #endif
03508 
03509 static int mark_input_file_SIZE(void *p) {
03510   return
03511   gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
03512 }
03513 
03514 static int mark_input_file_MARK(void *p) {
03515   Scheme_Input_File *i = (Scheme_Input_File *)p;
03516 
03517   gcMARK(i->f);
03518 
03519   return
03520   gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
03521 }
03522 
03523 static int mark_input_file_FIXUP(void *p) {
03524   Scheme_Input_File *i = (Scheme_Input_File *)p;
03525 
03526   gcFIXUP(i->f);
03527 
03528   return
03529   gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
03530 }
03531 
03532 #define mark_input_file_IS_ATOMIC 0
03533 #define mark_input_file_IS_CONST_SIZE 1
03534 
03535 
03536 static int mark_output_file_SIZE(void *p) {
03537   return
03538   gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
03539 }
03540 
03541 static int mark_output_file_MARK(void *p) {
03542   Scheme_Output_File *o = (Scheme_Output_File *)p;
03543 
03544   gcMARK(o->f);
03545 
03546   return
03547   gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
03548 }
03549 
03550 static int mark_output_file_FIXUP(void *p) {
03551   Scheme_Output_File *o = (Scheme_Output_File *)p;
03552 
03553   gcFIXUP(o->f);
03554 
03555   return
03556   gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
03557 }
03558 
03559 #define mark_output_file_IS_ATOMIC 0
03560 #define mark_output_file_IS_CONST_SIZE 1
03561 
03562 
03563 #ifdef MZ_FDS
03564 static int mark_input_fd_SIZE(void *p) {
03565   return
03566   gcBYTES_TO_WORDS(sizeof(Scheme_FD));
03567 }
03568 
03569 static int mark_input_fd_MARK(void *p) {
03570   Scheme_FD *fd = (Scheme_FD *)p;
03571 
03572   gcMARK(fd->buffer);
03573   gcMARK(fd->refcount);
03574 
03575   return
03576   gcBYTES_TO_WORDS(sizeof(Scheme_FD));
03577 }
03578 
03579 static int mark_input_fd_FIXUP(void *p) {
03580   Scheme_FD *fd = (Scheme_FD *)p;
03581 
03582   gcFIXUP(fd->buffer);
03583   gcFIXUP(fd->refcount);
03584 
03585   return
03586   gcBYTES_TO_WORDS(sizeof(Scheme_FD));
03587 }
03588 
03589 #define mark_input_fd_IS_ATOMIC 0
03590 #define mark_input_fd_IS_CONST_SIZE 1
03591 
03592 #endif
03593 
03594 #if defined(UNIX_PROCESSES)
03595 static int mark_system_child_SIZE(void *p) {
03596   return
03597   gcBYTES_TO_WORDS(sizeof(System_Child));
03598 }
03599 
03600 static int mark_system_child_MARK(void *p) {
03601   System_Child *sc = (System_Child *)p;
03602 
03603   gcMARK(sc->next);
03604 
03605   return
03606   gcBYTES_TO_WORDS(sizeof(System_Child));
03607 }
03608 
03609 static int mark_system_child_FIXUP(void *p) {
03610   System_Child *sc = (System_Child *)p;
03611 
03612   gcFIXUP(sc->next);
03613 
03614   return
03615   gcBYTES_TO_WORDS(sizeof(System_Child));
03616 }
03617 
03618 #define mark_system_child_IS_ATOMIC 0
03619 #define mark_system_child_IS_CONST_SIZE 1
03620 
03621 #endif
03622 
03623 #ifdef USE_OSKIT_CONSOLE
03624 static int mark_oskit_console_input_SIZE(void *p) {
03625   return
03626   gcBYTES_TO_WORDS(sizeof(osk_console_input));
03627 }
03628 
03629 static int mark_oskit_console_input_MARK(void *p) {
03630   osk_console_input *c = (osk_console_input *)p;
03631     
03632   gcMARK(c->buffer);
03633   gcMARK(c->next);
03634 
03635   return
03636   gcBYTES_TO_WORDS(sizeof(osk_console_input));
03637 }
03638 
03639 static int mark_oskit_console_input_FIXUP(void *p) {
03640   osk_console_input *c = (osk_console_input *)p;
03641     
03642   gcFIXUP(c->buffer);
03643   gcFIXUP(c->next);
03644 
03645   return
03646   gcBYTES_TO_WORDS(sizeof(osk_console_input));
03647 }
03648 
03649 #define mark_oskit_console_input_IS_ATOMIC 0
03650 #define mark_oskit_console_input_IS_CONST_SIZE 1
03651 
03652 #endif
03653 
03654 static int mark_subprocess_SIZE(void *p) {
03655   return
03656   gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
03657 }
03658 
03659 static int mark_subprocess_MARK(void *p) {
03660 #ifndef WINDOWS_PROCESSES
03661   Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
03662   gcMARK(sp->handle);
03663 #endif
03664   return
03665   gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
03666 }
03667 
03668 static int mark_subprocess_FIXUP(void *p) {
03669 #ifndef WINDOWS_PROCESSES
03670   Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
03671   gcFIXUP(sp->handle);
03672 #endif
03673   return
03674   gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
03675 }
03676 
03677 #define mark_subprocess_IS_ATOMIC 0
03678 #define mark_subprocess_IS_CONST_SIZE 1
03679 
03680 
03681 static int mark_read_write_evt_SIZE(void *p) {
03682   return
03683   gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
03684 }
03685 
03686 static int mark_read_write_evt_MARK(void *p) {
03687   Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
03688   gcMARK(rww->port);
03689   gcMARK(rww->v);
03690   gcMARK(rww->str);
03691   return
03692   gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
03693 }
03694 
03695 static int mark_read_write_evt_FIXUP(void *p) {
03696   Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
03697   gcFIXUP(rww->port);
03698   gcFIXUP(rww->v);
03699   gcFIXUP(rww->str);
03700   return
03701   gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
03702 }
03703 
03704 #define mark_read_write_evt_IS_ATOMIC 0
03705 #define mark_read_write_evt_IS_CONST_SIZE 1
03706 
03707 
03708 #endif  /* PORT */
03709 
03710 /**********************************************************************/
03711 
03712 #ifdef MARKS_FOR_PRINT_C
03713 
03714 static int mark_print_params_SIZE(void *p) {
03715   return
03716   gcBYTES_TO_WORDS(sizeof(PrintParams));
03717 }
03718 
03719 static int mark_print_params_MARK(void *p) {
03720   PrintParams *pp = (PrintParams *)p;
03721   gcMARK(pp->inspector);
03722   gcMARK(pp->print_port);
03723   gcMARK(pp->print_buffer);
03724   return
03725   gcBYTES_TO_WORDS(sizeof(PrintParams));
03726 }
03727 
03728 static int mark_print_params_FIXUP(void *p) {
03729   PrintParams *pp = (PrintParams *)p;
03730   gcFIXUP(pp->inspector);
03731   gcFIXUP(pp->print_port);
03732   gcFIXUP(pp->print_buffer);
03733   return
03734   gcBYTES_TO_WORDS(sizeof(PrintParams));
03735 }
03736 
03737 #define mark_print_params_IS_ATOMIC 0
03738 #define mark_print_params_IS_CONST_SIZE 1
03739 
03740 
03741 static int mark_marshal_tables_SIZE(void *p) {
03742   return
03743   gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
03744 }
03745 
03746 static int mark_marshal_tables_MARK(void *p) {
03747   Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
03748   gcMARK(mt->symtab);
03749   gcMARK(mt->rns);
03750   gcMARK(mt->rn_refs);
03751   gcMARK(mt->st_refs);
03752   gcMARK(mt->st_ref_stack);
03753   gcMARK(mt->reverse_map);
03754   gcMARK(mt->same_map);
03755   gcMARK(mt->cert_lists);
03756   gcMARK(mt->shift_map);
03757   gcMARK(mt->top_map);
03758   gcMARK(mt->key_map);
03759   gcMARK(mt->delay_map);
03760   gcMARK(mt->cdata_map);
03761   gcMARK(mt->rn_saved);
03762   gcMARK(mt->shared_offsets);
03763   gcMARK(mt->sorted_keys);
03764   return
03765   gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
03766 }
03767 
03768 static int mark_marshal_tables_FIXUP(void *p) {
03769   Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
03770   gcFIXUP(mt->symtab);
03771   gcFIXUP(mt->rns);
03772   gcFIXUP(mt->rn_refs);
03773   gcFIXUP(mt->st_refs);
03774   gcFIXUP(mt->st_ref_stack);
03775   gcFIXUP(mt->reverse_map);
03776   gcFIXUP(mt->same_map);
03777   gcFIXUP(mt->cert_lists);
03778   gcFIXUP(mt->shift_map);
03779   gcFIXUP(mt->top_map);
03780   gcFIXUP(mt->key_map);
03781   gcFIXUP(mt->delay_map);
03782   gcFIXUP(mt->cdata_map);
03783   gcFIXUP(mt->rn_saved);
03784   gcFIXUP(mt->shared_offsets);
03785   gcFIXUP(mt->sorted_keys);
03786   return
03787   gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
03788 }
03789 
03790 #define mark_marshal_tables_IS_ATOMIC 0
03791 #define mark_marshal_tables_IS_CONST_SIZE 1
03792 
03793 
03794 #endif  /* PRINT */
03795 
03796 /**********************************************************************/
03797 
03798 #ifdef MARKS_FOR_NETWORK_C
03799 
03800 static int mark_listener_SIZE(void *p) {
03801   listener_t *l = (listener_t *)p;
03802 
03803   return
03804   gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
03805 }
03806 
03807 static int mark_listener_MARK(void *p) {
03808   listener_t *l = (listener_t *)p;
03809 
03810 
03811   gcMARK(l->mref);
03812 
03813   return
03814   gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
03815 }
03816 
03817 static int mark_listener_FIXUP(void *p) {
03818   listener_t *l = (listener_t *)p;
03819 
03820 
03821   gcFIXUP(l->mref);
03822 
03823   return
03824   gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
03825 }
03826 
03827 #define mark_listener_IS_ATOMIC 0
03828 #define mark_listener_IS_CONST_SIZE 0
03829 
03830 
03831 #ifdef USE_TCP
03832 static int mark_tcp_SIZE(void *p) {
03833   return
03834   gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
03835 }
03836 
03837 static int mark_tcp_MARK(void *p) {
03838   Scheme_Tcp *tcp = (Scheme_Tcp *)p;
03839 
03840   gcMARK(tcp->b.buffer);
03841   gcMARK(tcp->b.out_buffer);
03842 
03843   return
03844   gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
03845 }
03846 
03847 static int mark_tcp_FIXUP(void *p) {
03848   Scheme_Tcp *tcp = (Scheme_Tcp *)p;
03849 
03850   gcFIXUP(tcp->b.buffer);
03851   gcFIXUP(tcp->b.out_buffer);
03852 
03853   return
03854   gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
03855 }
03856 
03857 #define mark_tcp_IS_ATOMIC 0
03858 #define mark_tcp_IS_CONST_SIZE 1
03859 
03860 
03861 # ifdef UDP_IS_SUPPORTED
03862 static int mark_udp_SIZE(void *p) {
03863   return
03864   gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
03865 }
03866 
03867 static int mark_udp_MARK(void *p) {
03868   Scheme_UDP *udp = (Scheme_UDP *)p;
03869 
03870   gcMARK(udp->previous_from_addr);
03871   gcMARK(udp->mref);
03872 
03873   return
03874   gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
03875 }
03876 
03877 static int mark_udp_FIXUP(void *p) {
03878   Scheme_UDP *udp = (Scheme_UDP *)p;
03879 
03880   gcFIXUP(udp->previous_from_addr);
03881   gcFIXUP(udp->mref);
03882 
03883   return
03884   gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
03885 }
03886 
03887 #define mark_udp_IS_ATOMIC 0
03888 #define mark_udp_IS_CONST_SIZE 1
03889 
03890 
03891 static int mark_udp_evt_SIZE(void *p) {
03892   return
03893   gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
03894 }
03895 
03896 static int mark_udp_evt_MARK(void *p) {
03897   Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
03898 
03899   gcMARK(uw->udp);
03900   gcMARK(uw->str);
03901   gcMARK(uw->dest_addr);
03902 
03903   return
03904   gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
03905 }
03906 
03907 static int mark_udp_evt_FIXUP(void *p) {
03908   Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
03909 
03910   gcFIXUP(uw->udp);
03911   gcFIXUP(uw->str);
03912   gcFIXUP(uw->dest_addr);
03913 
03914   return
03915   gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
03916 }
03917 
03918 #define mark_udp_evt_IS_ATOMIC 0
03919 #define mark_udp_evt_IS_CONST_SIZE 1
03920 
03921 # endif
03922 #endif
03923 
03924 #endif  /* NETWORK */
03925 
03926 /**********************************************************************/
03927 
03928 #ifdef MARKS_FOR_THREAD_C
03929 
03930 static int mark_parameterization_SIZE(void *p) {
03931   return
03932   gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
03933                   + ((max_configs - 1) * sizeof(Scheme_Object*))));
03934 }
03935 
03936 static int mark_parameterization_MARK(void *p) {
03937   Scheme_Parameterization *c = (Scheme_Parameterization *)p;
03938   int i;
03939     
03940   for (i = max_configs; i--; ) {
03941     gcMARK(c->prims[i]);
03942   }
03943   gcMARK(c->extensions);
03944 
03945   return
03946   gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
03947                   + ((max_configs - 1) * sizeof(Scheme_Object*))));
03948 }
03949 
03950 static int mark_parameterization_FIXUP(void *p) {
03951   Scheme_Parameterization *c = (Scheme_Parameterization *)p;
03952   int i;
03953     
03954   for (i = max_configs; i--; ) {
03955     gcFIXUP(c->prims[i]);
03956   }
03957   gcFIXUP(c->extensions);
03958 
03959   return
03960   gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
03961                   + ((max_configs - 1) * sizeof(Scheme_Object*))));
03962 }
03963 
03964 #define mark_parameterization_IS_ATOMIC 0
03965 #define mark_parameterization_IS_CONST_SIZE 0
03966 
03967 
03968 static int mark_config_SIZE(void *p) {
03969   return
03970   gcBYTES_TO_WORDS(sizeof(Scheme_Config));
03971 }
03972 
03973 static int mark_config_MARK(void *p) {
03974   Scheme_Config *config = (Scheme_Config *)p;
03975   gcMARK(config->key);
03976   gcMARK(config->cell);
03977   gcMARK(config->next);
03978   return
03979   gcBYTES_TO_WORDS(sizeof(Scheme_Config));
03980 }
03981 
03982 static int mark_config_FIXUP(void *p) {
03983   Scheme_Config *config = (Scheme_Config *)p;
03984   gcFIXUP(config->key);
03985   gcFIXUP(config->cell);
03986   gcFIXUP(config->next);
03987   return
03988   gcBYTES_TO_WORDS(sizeof(Scheme_Config));
03989 }
03990 
03991 #define mark_config_IS_ATOMIC 0
03992 #define mark_config_IS_CONST_SIZE 1
03993 
03994 
03995 static int mark_will_executor_val_SIZE(void *p) {
03996   return
03997   gcBYTES_TO_WORDS(sizeof(WillExecutor));
03998 }
03999 
04000 static int mark_will_executor_val_MARK(void *p) {
04001   WillExecutor *e = (WillExecutor *)p;
04002   
04003   gcMARK(e->sema);
04004   gcMARK(e->first);
04005   gcMARK(e->last);
04006 
04007   return
04008   gcBYTES_TO_WORDS(sizeof(WillExecutor));
04009 }
04010 
04011 static int mark_will_executor_val_FIXUP(void *p) {
04012   WillExecutor *e = (WillExecutor *)p;
04013   
04014   gcFIXUP(e->sema);
04015   gcFIXUP(e->first);
04016   gcFIXUP(e->last);
04017 
04018   return
04019   gcBYTES_TO_WORDS(sizeof(WillExecutor));
04020 }
04021 
04022 #define mark_will_executor_val_IS_ATOMIC 0
04023 #define mark_will_executor_val_IS_CONST_SIZE 1
04024 
04025 
04026 static int mark_custodian_val_SIZE(void *p) {
04027   return
04028   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
04029 }
04030 
04031 static int mark_custodian_val_MARK(void *p) {
04032   Scheme_Custodian *m = (Scheme_Custodian *)p;
04033   
04034   gcMARK(m->boxes);
04035   gcMARK(m->mrefs);
04036   gcMARK(m->closers);
04037   gcMARK(m->data);
04038 
04039   gcMARK(m->parent);
04040   gcMARK(m->sibling);
04041   gcMARK(m->children);
04042 
04043   gcMARK(m->global_next);
04044   gcMARK(m->global_prev);
04045 
04046   gcMARK(m->cust_boxes);
04047 
04048   return
04049   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
04050 }
04051 
04052 static int mark_custodian_val_FIXUP(void *p) {
04053   Scheme_Custodian *m = (Scheme_Custodian *)p;
04054   
04055   gcFIXUP(m->boxes);
04056   gcFIXUP(m->mrefs);
04057   gcFIXUP(m->closers);
04058   gcFIXUP(m->data);
04059 
04060   gcFIXUP(m->parent);
04061   gcFIXUP(m->sibling);
04062   gcFIXUP(m->children);
04063 
04064   gcFIXUP(m->global_next);
04065   gcFIXUP(m->global_prev);
04066 
04067   gcFIXUP(m->cust_boxes);
04068 
04069   return
04070   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
04071 }
04072 
04073 #define mark_custodian_val_IS_ATOMIC 0
04074 #define mark_custodian_val_IS_CONST_SIZE 1
04075 
04076 
04077 static int mark_custodian_box_val_SIZE(void *p) {
04078   return
04079   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
04080 }
04081 
04082 static int mark_custodian_box_val_MARK(void *p) {
04083   Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
04084   int sd = ((Scheme_Custodian *)GC_resolve(b->cust))->shut_down;
04085 
04086   gcMARK(b->cust);
04087   if (!sd) {
04088     gcMARK(b->v);
04089   }
04090 
04091   return
04092   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
04093 }
04094 
04095 static int mark_custodian_box_val_FIXUP(void *p) {
04096   Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
04097   int sd = ((Scheme_Custodian *)GC_resolve(b->cust))->shut_down;
04098 
04099   gcFIXUP(b->cust);
04100   if (!sd) {
04101     gcFIXUP(b->v);
04102   }
04103 
04104   return
04105   gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
04106 }
04107 
04108 #define mark_custodian_box_val_IS_ATOMIC 0
04109 #define mark_custodian_box_val_IS_CONST_SIZE 1
04110 
04111 
04112 static int mark_thread_hop_SIZE(void *p) {
04113   return
04114    gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
04115 }
04116 
04117 static int mark_thread_hop_MARK(void *p) {
04118   Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
04119 
04120   gcMARK(hop->p);
04121 
04122   return
04123    gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
04124 }
04125 
04126 static int mark_thread_hop_FIXUP(void *p) {
04127   Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
04128 
04129   gcFIXUP(hop->p);
04130 
04131   return
04132    gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
04133 }
04134 
04135 #define mark_thread_hop_IS_ATOMIC 0
04136 #define mark_thread_hop_IS_CONST_SIZE 1
04137 
04138 
04139 static int mark_namespace_option_SIZE(void *p) {
04140   return
04141   gcBYTES_TO_WORDS(sizeof(Scheme_NSO));
04142 }
04143 
04144 static int mark_namespace_option_MARK(void *p) {
04145   Scheme_NSO *o = (Scheme_NSO *)p;
04146 
04147   gcMARK(o->key);
04148 
04149   return
04150   gcBYTES_TO_WORDS(sizeof(Scheme_NSO));
04151 }
04152 
04153 static int mark_namespace_option_FIXUP(void *p) {
04154   Scheme_NSO *o = (Scheme_NSO *)p;
04155 
04156   gcFIXUP(o->key);
04157 
04158   return
04159   gcBYTES_TO_WORDS(sizeof(Scheme_NSO));
04160 }
04161 
04162 #define mark_namespace_option_IS_ATOMIC 0
04163 #define mark_namespace_option_IS_CONST_SIZE 1
04164 
04165 
04166 static int mark_param_data_SIZE(void *p) {
04167   return
04168    gcBYTES_TO_WORDS(sizeof(ParamData));
04169 }
04170 
04171 static int mark_param_data_MARK(void *p) {
04172   ParamData *d = (ParamData *)p;
04173 
04174   gcMARK(d->key);
04175   gcMARK(d->guard);
04176   gcMARK(d->extract_guard);
04177   gcMARK(d->defcell);
04178 
04179   return
04180    gcBYTES_TO_WORDS(sizeof(ParamData));
04181 }
04182 
04183 static int mark_param_data_FIXUP(void *p) {
04184   ParamData *d = (ParamData *)p;
04185 
04186   gcFIXUP(d->key);
04187   gcFIXUP(d->guard);
04188   gcFIXUP(d->extract_guard);
04189   gcFIXUP(d->defcell);
04190 
04191   return
04192    gcBYTES_TO_WORDS(sizeof(ParamData));
04193 }
04194 
04195 #define mark_param_data_IS_ATOMIC 0
04196 #define mark_param_data_IS_CONST_SIZE 1
04197 
04198 
04199 static int mark_will_SIZE(void *p) {
04200   return
04201   gcBYTES_TO_WORDS(sizeof(ActiveWill));
04202 }
04203 
04204 static int mark_will_MARK(void *p) {
04205   ActiveWill *w = (ActiveWill *)p;
04206   
04207   gcMARK(w->o);
04208   gcMARK(w->proc);
04209   gcMARK(w->w);
04210   gcMARK(w->next);
04211 
04212   return
04213   gcBYTES_TO_WORDS(sizeof(ActiveWill));
04214 }
04215 
04216 static int mark_will_FIXUP(void *p) {
04217   ActiveWill *w = (ActiveWill *)p;
04218   
04219   gcFIXUP(w->o);
04220   gcFIXUP(w->proc);
04221   gcFIXUP(w->w);
04222   gcFIXUP(w->next);
04223 
04224   return
04225   gcBYTES_TO_WORDS(sizeof(ActiveWill));
04226 }
04227 
04228 #define mark_will_IS_ATOMIC 0
04229 #define mark_will_IS_CONST_SIZE 1
04230 
04231 
04232 static int mark_evt_SIZE(void *p) {
04233   return
04234   gcBYTES_TO_WORDS(sizeof(Evt));
04235 }
04236 
04237 static int mark_evt_MARK(void *p) {
04238   return
04239   gcBYTES_TO_WORDS(sizeof(Evt));
04240 }
04241 
04242 static int mark_evt_FIXUP(void *p) {
04243   return
04244   gcBYTES_TO_WORDS(sizeof(Evt));
04245 }
04246 
04247 #define mark_evt_IS_ATOMIC 1
04248 #define mark_evt_IS_CONST_SIZE 1
04249 
04250 
04251 static int mark_syncing_SIZE(void *p) {
04252   return
04253   gcBYTES_TO_WORDS(sizeof(Syncing));
04254 }
04255 
04256 static int mark_syncing_MARK(void *p) {
04257   Syncing *w = (Syncing *)p;
04258  
04259   gcMARK(w->set);
04260   gcMARK(w->wrapss);
04261   gcMARK(w->nackss);
04262   gcMARK(w->reposts);
04263   gcMARK(w->accepts);
04264   gcMARK(w->disable_break);
04265 
04266   return
04267   gcBYTES_TO_WORDS(sizeof(Syncing));
04268 }
04269 
04270 static int mark_syncing_FIXUP(void *p) {
04271   Syncing *w = (Syncing *)p;
04272  
04273   gcFIXUP(w->set);
04274   gcFIXUP(w->wrapss);
04275   gcFIXUP(w->nackss);
04276   gcFIXUP(w->reposts);
04277   gcFIXUP(w->accepts);
04278   gcFIXUP(w->disable_break);
04279 
04280   return
04281   gcBYTES_TO_WORDS(sizeof(Syncing));
04282 }
04283 
04284 #define mark_syncing_IS_ATOMIC 0
04285 #define mark_syncing_IS_CONST_SIZE 1
04286 
04287 
04288 static int mark_evt_set_SIZE(void *p) {
04289   return
04290   gcBYTES_TO_WORDS(sizeof(Evt_Set));
04291 }
04292 
04293 static int mark_evt_set_MARK(void *p) {
04294   Evt_Set *w = (Evt_Set *)p;
04295  
04296   gcMARK(w->ws);
04297   gcMARK(w->argv);
04298 
04299   return
04300   gcBYTES_TO_WORDS(sizeof(Evt_Set));
04301 }
04302 
04303 static int mark_evt_set_FIXUP(void *p) {
04304   Evt_Set *w = (Evt_Set *)p;
04305  
04306   gcFIXUP(w->ws);
04307   gcFIXUP(w->argv);
04308 
04309   return
04310   gcBYTES_TO_WORDS(sizeof(Evt_Set));
04311 }
04312 
04313 #define mark_evt_set_IS_ATOMIC 0
04314 #define mark_evt_set_IS_CONST_SIZE 1
04315 
04316 
04317 static int mark_thread_set_SIZE(void *p) {
04318   return
04319   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
04320 }
04321 
04322 static int mark_thread_set_MARK(void *p) {
04323   Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
04324  
04325   gcMARK(ts->parent);
04326   gcMARK(ts->first);
04327   gcMARK(ts->next);
04328   gcMARK(ts->prev);
04329   gcMARK(ts->search_start);
04330   gcMARK(ts->current);
04331 
04332   return
04333   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
04334 }
04335 
04336 static int mark_thread_set_FIXUP(void *p) {
04337   Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
04338  
04339   gcFIXUP(ts->parent);
04340   gcFIXUP(ts->first);
04341   gcFIXUP(ts->next);
04342   gcFIXUP(ts->prev);
04343   gcFIXUP(ts->search_start);
04344   gcFIXUP(ts->current);
04345 
04346   return
04347   gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
04348 }
04349 
04350 #define mark_thread_set_IS_ATOMIC 0
04351 #define mark_thread_set_IS_CONST_SIZE 1
04352 
04353 
04354 static int mark_thread_cell_SIZE(void *p) {
04355   return
04356   gcBYTES_TO_WORDS(sizeof(Thread_Cell));
04357 }
04358 
04359 static int mark_thread_cell_MARK(void *p) {
04360   Thread_Cell *c = (Thread_Cell *)p;
04361  
04362   gcMARK(c->def_val);
04363 
04364   return
04365   gcBYTES_TO_WORDS(sizeof(Thread_Cell));
04366 }
04367 
04368 static int mark_thread_cell_FIXUP(void *p) {
04369   Thread_Cell *c = (Thread_Cell *)p;
04370  
04371   gcFIXUP(c->def_val);
04372 
04373   return
04374   gcBYTES_TO_WORDS(sizeof(Thread_Cell));
04375 }
04376 
04377 #define mark_thread_cell_IS_ATOMIC 0
04378 #define mark_thread_cell_IS_CONST_SIZE 1
04379 
04380 
04381 #endif  /* THREAD */
04382 
04383 /**********************************************************************/
04384 
04385 #ifdef MARKS_FOR_SALLOC_C
04386 
04387 static int mark_finalization_SIZE(void *p) {
04388   return
04389   gcBYTES_TO_WORDS(sizeof(Finalization));
04390 }
04391 
04392 static int mark_finalization_MARK(void *p) {
04393   Finalization *f = (Finalization *)p;
04394   
04395   gcMARK(f->data);
04396   gcMARK(f->next);
04397   gcMARK(f->prev);
04398 
04399   return
04400   gcBYTES_TO_WORDS(sizeof(Finalization));
04401 }
04402 
04403 static int mark_finalization_FIXUP(void *p) {
04404   Finalization *f = (Finalization *)p;
04405   
04406   gcFIXUP(f->data);
04407   gcFIXUP(f->next);
04408   gcFIXUP(f->prev);
04409 
04410   return
04411   gcBYTES_TO_WORDS(sizeof(Finalization));
04412 }
04413 
04414 #define mark_finalization_IS_ATOMIC 0
04415 #define mark_finalization_IS_CONST_SIZE 1
04416 
04417 
04418 static int mark_finalizations_SIZE(void *p) {
04419   return
04420   gcBYTES_TO_WORDS(sizeof(Finalizations));
04421 }
04422 
04423 static int mark_finalizations_MARK(void *p) {
04424   Finalizations *f = (Finalizations *)p;
04425 
04426   gcMARK(f->scheme_first);
04427   gcMARK(f->scheme_last);
04428   gcMARK(f->prim_first);
04429   gcMARK(f->prim_last);
04430   gcMARK(f->ext_data);
04431 
04432   return
04433   gcBYTES_TO_WORDS(sizeof(Finalizations));
04434 }
04435 
04436 static int mark_finalizations_FIXUP(void *p) {
04437   Finalizations *f = (Finalizations *)p;
04438 
04439   gcFIXUP(f->scheme_first);
04440   gcFIXUP(f->scheme_last);
04441   gcFIXUP(f->prim_first);
04442   gcFIXUP(f->prim_last);
04443   gcFIXUP(f->ext_data);
04444 
04445   return
04446   gcBYTES_TO_WORDS(sizeof(Finalizations));
04447 }
04448 
04449 #define mark_finalizations_IS_ATOMIC 0
04450 #define mark_finalizations_IS_CONST_SIZE 1
04451 
04452 
04453 #endif  /* SALLOC */
04454 
04455 /**********************************************************************/
04456 
04457 #ifdef MARKS_FOR_SEMA_C
04458 
04459 static int mark_channel_syncer_SIZE(void *p) {
04460   return
04461   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
04462 }
04463 
04464 static int mark_channel_syncer_MARK(void *p) {
04465   Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
04466 
04467   gcMARK(w->p);
04468   gcMARK(w->prev);
04469   gcMARK(w->next);
04470   gcMARK(w->syncing);
04471   gcMARK(w->obj);
04472 
04473   return
04474   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
04475 }
04476 
04477 static int mark_channel_syncer_FIXUP(void *p) {
04478   Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
04479 
04480   gcFIXUP(w->p);
04481   gcFIXUP(w->prev);
04482   gcFIXUP(w->next);
04483   gcFIXUP(w->syncing);
04484   gcFIXUP(w->obj);
04485 
04486   return
04487   gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
04488 }
04489 
04490 #define mark_channel_syncer_IS_ATOMIC 0
04491 #define mark_channel_syncer_IS_CONST_SIZE 1
04492 
04493 
04494 static int mark_alarm_SIZE(void *p) {
04495   return
04496   gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
04497 }
04498 
04499 static int mark_alarm_MARK(void *p) {
04500   return
04501   gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
04502 }
04503 
04504 static int mark_alarm_FIXUP(void *p) {
04505   return
04506   gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
04507 }
04508 
04509 #define mark_alarm_IS_ATOMIC 1
04510 #define mark_alarm_IS_CONST_SIZE 1
04511 
04512 
04513 #endif  /* SEMA */
04514 
04515 /**********************************************************************/
04516 
04517 #ifdef MARKS_FOR_STRUCT_C
04518 
04519 static int mark_struct_val_SIZE(void *p) {
04520   Scheme_Structure *s = (Scheme_Structure *)p;
04521   int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots;
04522 
04523   return
04524   gcBYTES_TO_WORDS((sizeof(Scheme_Structure) 
04525                   + ((num_slots - 1) * sizeof(Scheme_Object *))));
04526 }
04527 
04528 static int mark_struct_val_MARK(void *p) {
04529   Scheme_Structure *s = (Scheme_Structure *)p;
04530   int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots;
04531 
04532   int i;
04533 
04534   gcMARK( s->stype);
04535   
04536   for(i = num_slots; i--; )
04537     gcMARK(s->slots[i]);
04538 
04539   return
04540   gcBYTES_TO_WORDS((sizeof(Scheme_Structure) 
04541                   + ((num_slots - 1) * sizeof(Scheme_Object *))));
04542 }
04543 
04544 static int mark_struct_val_FIXUP(void *p) {
04545   Scheme_Structure *s = (Scheme_Structure *)p;
04546   int num_slots = ((Scheme_Struct_Type *)GC_resolve(s->stype))->num_slots;
04547 
04548   int i;
04549 
04550   gcFIXUP_TYPED_NOW(Scheme_Struct_Type *, s->stype);
04551   
04552   for(i = num_slots; i--; )
04553     gcFIXUP(s->slots[i]);
04554 
04555   return
04556   gcBYTES_TO_WORDS((sizeof(Scheme_Structure) 
04557                   + ((num_slots - 1) * sizeof(Scheme_Object *))));
04558 }
04559 
04560 #define mark_struct_val_IS_ATOMIC 0
04561 #define mark_struct_val_IS_CONST_SIZE 0
04562 
04563 
04564 static int mark_struct_type_val_SIZE(void *p) {
04565   Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
04566 
04567   return
04568   gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
04569                   + (t->name_pos * sizeof(Scheme_Struct_Type *))));
04570 }
04571 
04572 static int mark_struct_type_val_MARK(void *p) {
04573   Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
04574 
04575   int i;
04576   for (i = t->name_pos + 1; i--; ) {
04577     gcMARK(t->parent_types[i]);
04578   }
04579   gcMARK(t->name);
04580   gcMARK(t->inspector);
04581   gcMARK(t->accessor);
04582   gcMARK(t->mutator);
04583   gcMARK(t->prefab_key);
04584   gcMARK(t->uninit_val);
04585   gcMARK(t->props);
04586   gcMARK(t->proc_attr);
04587   gcMARK(t->guard);
04588   gcMARK(t->immutables);
04589 
04590   return
04591   gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
04592                   + (t->name_pos * sizeof(Scheme_Struct_Type *))));
04593 }
04594 
04595 static int mark_struct_type_val_FIXUP(void *p) {
04596   Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
04597 
04598   int i;
04599   for (i = t->name_pos + 1; i--; ) {
04600     gcFIXUP(t->parent_types[i]);
04601   }
04602   gcFIXUP(t->name);
04603   gcFIXUP(t->inspector);
04604   gcFIXUP(t->accessor);
04605   gcFIXUP(t->mutator);
04606   gcFIXUP(t->prefab_key);
04607   gcFIXUP(t->uninit_val);
04608   gcFIXUP(t->props);
04609   gcFIXUP(t->proc_attr);
04610   gcFIXUP(t->guard);
04611   gcFIXUP(t->immutables);
04612 
04613   return
04614   gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
04615                   + (t->name_pos * sizeof(Scheme_Struct_Type *))));
04616 }
04617 
04618 #define mark_struct_type_val_IS_ATOMIC 0
04619 #define mark_struct_type_val_IS_CONST_SIZE 0
04620 
04621 
04622 static int mark_struct_proc_info_SIZE(void *p) {
04623   return
04624   gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
04625 }
04626 
04627 static int mark_struct_proc_info_MARK(void *p) {
04628   Struct_Proc_Info *i = (Struct_Proc_Info *)p;
04629 
04630   gcMARK(i->struct_type);
04631   gcMARK(i->func_name);
04632 
04633   return
04634   gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
04635 }
04636 
04637 static int mark_struct_proc_info_FIXUP(void *p) {
04638   Struct_Proc_Info *i = (Struct_Proc_Info *)p;
04639 
04640   gcFIXUP(i->struct_type);
04641   gcFIXUP(i->func_name);
04642 
04643   return
04644   gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
04645 }
04646 
04647 #define mark_struct_proc_info_IS_ATOMIC 0
04648 #define mark_struct_proc_info_IS_CONST_SIZE 1
04649 
04650 
04651 static int mark_struct_property_SIZE(void *p) {
04652   return
04653   gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
04654 }
04655 
04656 static int mark_struct_property_MARK(void *p) {
04657   Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
04658   gcMARK(i->name);
04659   gcMARK(i->guard);
04660   gcMARK(i->supers);
04661   return
04662   gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
04663 }
04664 
04665 static int mark_struct_property_FIXUP(void *p) {
04666   Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
04667   gcFIXUP(i->name);
04668   gcFIXUP(i->guard);
04669   gcFIXUP(i->supers);
04670   return
04671   gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
04672 }
04673 
04674 #define mark_struct_property_IS_ATOMIC 0
04675 #define mark_struct_property_IS_CONST_SIZE 1
04676 
04677 
04678 static int mark_wrapped_evt_SIZE(void *p) {
04679   return
04680   gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
04681 }
04682 
04683 static int mark_wrapped_evt_MARK(void *p) {
04684   Wrapped_Evt *ww = (Wrapped_Evt *)p;
04685 
04686   gcMARK(ww->evt);
04687   gcMARK(ww->wrapper);
04688 
04689   return
04690   gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
04691 }
04692 
04693 static int mark_wrapped_evt_FIXUP(void *p) {
04694   Wrapped_Evt *ww = (Wrapped_Evt *)p;
04695 
04696   gcFIXUP(ww->evt);
04697   gcFIXUP(ww->wrapper);
04698 
04699   return
04700   gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
04701 }
04702 
04703 #define mark_wrapped_evt_IS_ATOMIC 0
04704 #define mark_wrapped_evt_IS_CONST_SIZE 1
04705 
04706 
04707 static int mark_nack_guard_evt_SIZE(void *p) {
04708   return
04709   gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
04710 }
04711 
04712 static int mark_nack_guard_evt_MARK(void *p) {
04713   Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
04714 
04715   gcMARK(nw->maker);
04716 
04717   return
04718   gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
04719 }
04720 
04721 static int mark_nack_guard_evt_FIXUP(void *p) {
04722   Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
04723 
04724   gcFIXUP(nw->maker);
04725 
04726   return
04727   gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
04728 }
04729 
04730 #define mark_nack_guard_evt_IS_ATOMIC 0
04731 #define mark_nack_guard_evt_IS_CONST_SIZE 1
04732 
04733 
04734 #endif  /* STRUCT */
04735 
04736 /**********************************************************************/
04737 
04738 #ifdef MARKS_FOR_SYNTAX_C
04739 
04740 #endif  /* SYNTAX */
04741 
04742 /**********************************************************************/
04743 
04744 #ifdef MARKS_FOR_READ_C
04745 
04746 static int mark_indent_SIZE(void *p) {
04747   return
04748   gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
04749 }
04750 
04751 static int mark_indent_MARK(void *p) {
04752   return
04753   gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
04754 }
04755 
04756 static int mark_indent_FIXUP(void *p) {
04757   return
04758   gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
04759 }
04760 
04761 #define mark_indent_IS_ATOMIC 1
04762 #define mark_indent_IS_CONST_SIZE 1
04763 
04764 
04765 static int mark_cport_SIZE(void *p) {
04766   return
04767   gcBYTES_TO_WORDS(sizeof(CPort));
04768 }
04769 
04770 static int mark_cport_MARK(void *p) {
04771   CPort *cp = (CPort *)p;
04772   gcMARK(cp->start);
04773   gcMARK(cp->orig_port);
04774   gcMARK(cp->ht);
04775   gcMARK(cp->ut);
04776   gcMARK(cp->symtab);
04777   gcMARK(cp->insp);
04778   gcMARK(cp->relto);
04779   gcMARK(cp->magic_sym);
04780   gcMARK(cp->magic_val);
04781   gcMARK(cp->shared_offsets);
04782   gcMARK(cp->delay_info);
04783   return
04784   gcBYTES_TO_WORDS(sizeof(CPort));
04785 }
04786 
04787 static int mark_cport_FIXUP(void *p) {
04788   CPort *cp = (CPort *)p;
04789   gcFIXUP(cp->start);
04790   gcFIXUP(cp->orig_port);
04791   gcFIXUP(cp->ht);
04792   gcFIXUP(cp->ut);
04793   gcFIXUP(cp->symtab);
04794   gcFIXUP(cp->insp);
04795   gcFIXUP(cp->relto);
04796   gcFIXUP(cp->magic_sym);
04797   gcFIXUP(cp->magic_val);
04798   gcFIXUP(cp->shared_offsets);
04799   gcFIXUP(cp->delay_info);
04800   return
04801   gcBYTES_TO_WORDS(sizeof(CPort));
04802 }
04803 
04804 #define mark_cport_IS_ATOMIC 0
04805 #define mark_cport_IS_CONST_SIZE 1
04806 
04807 
04808 static int mark_readtable_SIZE(void *p) {
04809   return
04810   gcBYTES_TO_WORDS(sizeof(Readtable));
04811 }
04812 
04813 static int mark_readtable_MARK(void *p) {
04814   Readtable *t = (Readtable *)p;
04815   gcMARK(t->mapping);
04816   gcMARK(t->fast_mapping);
04817   gcMARK(t->symbol_parser);
04818   gcMARK(t->names);
04819   return
04820   gcBYTES_TO_WORDS(sizeof(Readtable));
04821 }
04822 
04823 static int mark_readtable_FIXUP(void *p) {
04824   Readtable *t = (Readtable *)p;
04825   gcFIXUP(t->mapping);
04826   gcFIXUP(t->fast_mapping);
04827   gcFIXUP(t->symbol_parser);
04828   gcFIXUP(t->names);
04829   return
04830   gcBYTES_TO_WORDS(sizeof(Readtable));
04831 }
04832 
04833 #define mark_readtable_IS_ATOMIC 0
04834 #define mark_readtable_IS_CONST_SIZE 1
04835 
04836 
04837 static int mark_read_params_SIZE(void *p) {
04838   return
04839   gcBYTES_TO_WORDS(sizeof(ReadParams));
04840 }
04841 
04842 static int mark_read_params_MARK(void *p) {
04843   ReadParams *rp = (ReadParams *)p;
04844   gcMARK(rp->table);
04845   gcMARK(rp->magic_sym);
04846   gcMARK(rp->magic_val);
04847   gcMARK(rp->delay_load_info);
04848   return
04849   gcBYTES_TO_WORDS(sizeof(ReadParams));
04850 }
04851 
04852 static int mark_read_params_FIXUP(void *p) {
04853   ReadParams *rp = (ReadParams *)p;
04854   gcFIXUP(rp->table);
04855   gcFIXUP(rp->magic_sym);
04856   gcFIXUP(rp->magic_val);
04857   gcFIXUP(rp->delay_load_info);
04858   return
04859   gcBYTES_TO_WORDS(sizeof(ReadParams));
04860 }
04861 
04862 #define mark_read_params_IS_ATOMIC 0
04863 #define mark_read_params_IS_CONST_SIZE 1
04864 
04865 
04866 static int mark_delay_load_SIZE(void *p) {
04867   return
04868   gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
04869 }
04870 
04871 static int mark_delay_load_MARK(void *p) {
04872   Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
04873   gcMARK(ld->path);
04874   gcMARK(ld->symtab);
04875   gcMARK(ld->shared_offsets);
04876   gcMARK(ld->insp);
04877   gcMARK(ld->relto);
04878   gcMARK(ld->ut);
04879   gcMARK(ld->current_rp);
04880   gcMARK(ld->cached);
04881   gcMARK(ld->cached_port);
04882   return
04883   gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
04884 }
04885 
04886 static int mark_delay_load_FIXUP(void *p) {
04887   Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
04888   gcFIXUP(ld->path);
04889   gcFIXUP(ld->symtab);
04890   gcFIXUP(ld->shared_offsets);
04891   gcFIXUP(ld->insp);
04892   gcFIXUP(ld->relto);
04893   gcFIXUP(ld->ut);
04894   gcFIXUP(ld->current_rp);
04895   gcFIXUP(ld->cached);
04896   gcFIXUP(ld->cached_port);
04897   return
04898   gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
04899 }
04900 
04901 #define mark_delay_load_IS_ATOMIC 0
04902 #define mark_delay_load_IS_CONST_SIZE 1
04903 
04904 
04905 static int mark_unmarshal_tables_SIZE(void *p) {
04906   return
04907   gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
04908 }
04909 
04910 static int mark_unmarshal_tables_MARK(void *p) {
04911   Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
04912   gcMARK(ut->rns);
04913   gcMARK(ut->rp);
04914   gcMARK(ut->decoded);
04915   return
04916   gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
04917 }
04918 
04919 static int mark_unmarshal_tables_FIXUP(void *p) {
04920   Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
04921   gcFIXUP(ut->rns);
04922   gcFIXUP(ut->rp);
04923   gcFIXUP(ut->decoded);
04924   return
04925   gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
04926 }
04927 
04928 #define mark_unmarshal_tables_IS_ATOMIC 0
04929 #define mark_unmarshal_tables_IS_CONST_SIZE 1
04930 
04931 
04932 #endif  /* READ */
04933 
04934 /**********************************************************************/
04935 
04936 #ifdef MARKS_FOR_REGEXP_C
04937 
04938 static int mark_regexp_SIZE(void *p) {
04939   regexp *r = (regexp *)p;
04940   return
04941   gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
04942 }
04943 
04944 static int mark_regexp_MARK(void *p) {
04945   regexp *r = (regexp *)p;
04946   gcMARK(r->source);
04947   gcMARK(r->regstart);
04948   return
04949   gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
04950 }
04951 
04952 static int mark_regexp_FIXUP(void *p) {
04953   regexp *r = (regexp *)p;
04954   gcFIXUP(r->source);
04955   gcFIXUP(r->regstart);
04956   return
04957   gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
04958 }
04959 
04960 #define mark_regexp_IS_ATOMIC 0
04961 #define mark_regexp_IS_CONST_SIZE 0
04962 
04963 
04964 static int mark_regwork_SIZE(void *p) {
04965   return
04966   gcBYTES_TO_WORDS(sizeof(Regwork));
04967 }
04968 
04969 static int mark_regwork_MARK(void *p) {
04970   Regwork *r = (Regwork *)p;
04971   gcMARK(r->str);
04972   gcMARK(r->instr);
04973   gcMARK(r->port);
04974   gcMARK(r->unless_evt);
04975   gcMARK(r->startp);
04976   gcMARK(r->maybep);
04977   gcMARK(r->endp);
04978   gcMARK(r->counters);
04979   gcMARK(r->peekskip);
04980   return
04981   gcBYTES_TO_WORDS(sizeof(Regwork));
04982 }
04983 
04984 static int mark_regwork_FIXUP(void *p) {
04985   Regwork *r = (Regwork *)p;
04986   gcFIXUP(r->str);
04987   gcFIXUP(r->instr);
04988   gcFIXUP(r->port);
04989   gcFIXUP(r->unless_evt);
04990   gcFIXUP(r->startp);
04991   gcFIXUP(r->maybep);
04992   gcFIXUP(r->endp);
04993   gcFIXUP(r->counters);
04994   gcFIXUP(r->peekskip);
04995   return
04996   gcBYTES_TO_WORDS(sizeof(Regwork));
04997 }
04998 
04999 #define mark_regwork_IS_ATOMIC 0
05000 #define mark_regwork_IS_CONST_SIZE 1
05001 
05002 
05003 #endif  /* REGEXP */
05004 
05005 /**********************************************************************/
05006 
05007 #ifdef MARKS_FOR_STRING_C
05008 
05009 static int mark_string_convert_SIZE(void *p) {
05010   return
05011   gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
05012 }
05013 
05014 static int mark_string_convert_MARK(void *p) {
05015   Scheme_Converter *c = (Scheme_Converter *)p;
05016   gcMARK(c->mref);
05017   return
05018   gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
05019 }
05020 
05021 static int mark_string_convert_FIXUP(void *p) {
05022   Scheme_Converter *c = (Scheme_Converter *)p;
05023   gcFIXUP(c->mref);
05024   return
05025   gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
05026 }
05027 
05028 #define mark_string_convert_IS_ATOMIC 0
05029 #define mark_string_convert_IS_CONST_SIZE 1
05030 
05031 
05032 #endif  /* STRING */
05033 
05034 /**********************************************************************/
05035 
05036 #ifdef MARKS_FOR_STXOBJ_C
05037 
05038 static int mark_rename_table_SIZE(void *p) {
05039   return
05040   gcBYTES_TO_WORDS(sizeof(Module_Renames));
05041 }
05042 
05043 static int mark_rename_table_MARK(void *p) {
05044   Module_Renames *rn = (Module_Renames *)p;
05045   gcMARK(rn->phase);
05046   gcMARK(rn->ht);
05047   gcMARK(rn->nomarshal_ht);
05048   gcMARK(rn->unmarshal_info);
05049   gcMARK(rn->shared_pes);
05050   gcMARK(rn->set_identity);
05051   gcMARK(rn->marked_names);
05052   gcMARK(rn->free_id_renames);
05053   return
05054   gcBYTES_TO_WORDS(sizeof(Module_Renames));
05055 }
05056 
05057 static int mark_rename_table_FIXUP(void *p) {
05058   Module_Renames *rn = (Module_Renames *)p;
05059   gcFIXUP(rn->phase);
05060   gcFIXUP(rn->ht);
05061   gcFIXUP(rn->nomarshal_ht);
05062   gcFIXUP(rn->unmarshal_info);
05063   gcFIXUP(rn->shared_pes);
05064   gcFIXUP(rn->set_identity);
05065   gcFIXUP(rn->marked_names);
05066   gcFIXUP(rn->free_id_renames);
05067   return
05068   gcBYTES_TO_WORDS(sizeof(Module_Renames));
05069 }
05070 
05071 #define mark_rename_table_IS_ATOMIC 0
05072 #define mark_rename_table_IS_CONST_SIZE 1
05073 
05074 
05075 static int mark_rename_table_set_SIZE(void *p) {
05076   return
05077   gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
05078 }
05079 
05080 static int mark_rename_table_set_MARK(void *p) {
05081   Module_Renames_Set *rns = (Module_Renames_Set *)p;
05082   gcMARK(rns->et);
05083   gcMARK(rns->rt);
05084   gcMARK(rns->other_phases);
05085   gcMARK(rns->share_marked_names);
05086   gcMARK(rns->set_identity);
05087   return
05088   gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
05089 }
05090 
05091 static int mark_rename_table_set_FIXUP(void *p) {
05092   Module_Renames_Set *rns = (Module_Renames_Set *)p;
05093   gcFIXUP(rns->et);
05094   gcFIXUP(rns->rt);
05095   gcFIXUP(rns->other_phases);
05096   gcFIXUP(rns->share_marked_names);
05097   gcFIXUP(rns->set_identity);
05098   return
05099   gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
05100 }
05101 
05102 #define mark_rename_table_set_IS_ATOMIC 0
05103 #define mark_rename_table_set_IS_CONST_SIZE 1
05104 
05105 
05106 static int mark_srcloc_SIZE(void *p) {
05107   return
05108   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
05109 }
05110 
05111 static int mark_srcloc_MARK(void *p) {
05112   Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
05113   gcMARK(s->src);
05114   return
05115   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
05116 }
05117 
05118 static int mark_srcloc_FIXUP(void *p) {
05119   Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
05120   gcFIXUP(s->src);
05121   return
05122   gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
05123 }
05124 
05125 #define mark_srcloc_IS_ATOMIC 0
05126 #define mark_srcloc_IS_CONST_SIZE 1
05127 
05128 
05129 static int mark_wrapchunk_SIZE(void *p) {
05130   Wrap_Chunk *wc = (Wrap_Chunk *)p;
05131   return
05132   gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
05133 }
05134 
05135 static int mark_wrapchunk_MARK(void *p) {
05136   Wrap_Chunk *wc = (Wrap_Chunk *)p;
05137   int i;
05138   for (i = wc->len; i--; ) {
05139     gcMARK(wc->a[i]);
05140   }
05141   return
05142   gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
05143 }
05144 
05145 static int mark_wrapchunk_FIXUP(void *p) {
05146   Wrap_Chunk *wc = (Wrap_Chunk *)p;
05147   int i;
05148   for (i = wc->len; i--; ) {
05149     gcFIXUP(wc->a[i]);
05150   }
05151   return
05152   gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
05153 }
05154 
05155 #define mark_wrapchunk_IS_ATOMIC 0
05156 #define mark_wrapchunk_IS_CONST_SIZE 0
05157 
05158 
05159 static int mark_cert_SIZE(void *p) {
05160   return
05161   gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
05162 }
05163 
05164 static int mark_cert_MARK(void *p) {
05165   Scheme_Cert *c = (Scheme_Cert *)p;
05166   gcMARK(c->mark);
05167   gcMARK(c->modidx);
05168   gcMARK(c->insp);
05169   gcMARK(c->key);
05170   gcMARK(c->mapped);
05171   gcMARK(c->next);
05172   return
05173   gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
05174 }
05175 
05176 static int mark_cert_FIXUP(void *p) {
05177   Scheme_Cert *c = (Scheme_Cert *)p;
05178   gcFIXUP(c->mark);
05179   gcFIXUP(c->modidx);
05180   gcFIXUP(c->insp);
05181   gcFIXUP(c->key);
05182   gcFIXUP(c->mapped);
05183   gcFIXUP(c->next);
05184   return
05185   gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
05186 }
05187 
05188 #define mark_cert_IS_ATOMIC 0
05189 #define mark_cert_IS_CONST_SIZE 1
05190 
05191 
05192 static int lex_rib_SIZE(void *p) {
05193   return
05194   gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
05195 }
05196 
05197 static int lex_rib_MARK(void *p) {
05198   Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p;
05199   gcMARK(rib->rename);
05200   gcMARK(rib->timestamp);
05201   gcMARK(rib->sealed);
05202   gcMARK(rib->next);
05203   return
05204   gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
05205 }
05206 
05207 static int lex_rib_FIXUP(void *p) {
05208   Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p;
05209   gcFIXUP(rib->rename);
05210   gcFIXUP(rib->timestamp);
05211   gcFIXUP(rib->sealed);
05212   gcFIXUP(rib->next);
05213   return
05214   gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
05215 }
05216 
05217 #define lex_rib_IS_ATOMIC 0
05218 #define lex_rib_IS_CONST_SIZE 1
05219 
05220 
05221 static int mark_free_id_info_SIZE(void *p) {
05222   return
05223   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
05224                   + ((8 - 1) * sizeof(Scheme_Object *))));
05225 }
05226 
05227 static int mark_free_id_info_MARK(void *p) {
05228   Scheme_Vector *vec = (Scheme_Vector *)p;
05229   int i;
05230   for (i = 8; i--; )
05231     gcMARK(vec->els[i]);
05232 
05233   return
05234   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
05235                   + ((8 - 1) * sizeof(Scheme_Object *))));
05236 }
05237 
05238 static int mark_free_id_info_FIXUP(void *p) {
05239   Scheme_Vector *vec = (Scheme_Vector *)p;
05240   int i;
05241   for (i = 8; i--; )
05242     gcFIXUP(vec->els[i]);
05243 
05244   return
05245   gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 
05246                   + ((8 - 1) * sizeof(Scheme_Object *))));
05247 }
05248 
05249 #define mark_free_id_info_IS_ATOMIC 0
05250 #define mark_free_id_info_IS_CONST_SIZE 0
05251 
05252 
05253 
05254 
05255 #endif  /* STXOBJ */
05256 
05257 /**********************************************************************/
05258 
05259 #ifdef MARKS_FOR_JIT_C
05260 
05261 static int native_closure_SIZE(void *p) {
05262   Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
05263   int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size;
05264 
05265   if (closure_size < 0) {
05266     closure_size = -(closure_size + 1);
05267   }
05268 
05269   return
05270   gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
05271                   + (closure_size - 1) * sizeof(Scheme_Object *)));
05272 }
05273 
05274 static int native_closure_MARK(void *p) {
05275   Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
05276   int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size;
05277 
05278   if (closure_size < 0) {
05279     closure_size = -(closure_size + 1);
05280   }
05281 
05282 
05283   {
05284     int i = closure_size;
05285     while (i--)
05286       gcMARK(c->vals[i]);
05287   }
05288   gcMARK(c->code);
05289   
05290   return
05291   gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
05292                   + (closure_size - 1) * sizeof(Scheme_Object *)));
05293 }
05294 
05295 static int native_closure_FIXUP(void *p) {
05296   Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
05297   int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve(c->code))->closure_size;
05298 
05299   if (closure_size < 0) {
05300     closure_size = -(closure_size + 1);
05301   }
05302 
05303 
05304   {
05305     int i = closure_size;
05306     while (i--)
05307       gcFIXUP(c->vals[i]);
05308   }
05309   gcFIXUP(c->code);
05310   
05311   return
05312   gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
05313                   + (closure_size - 1) * sizeof(Scheme_Object *)));
05314 }
05315 
05316 #define native_closure_IS_ATOMIC 0
05317 #define native_closure_IS_CONST_SIZE 0
05318 
05319 
05320 static int mark_jit_state_SIZE(void *p) {
05321   return
05322   gcBYTES_TO_WORDS(sizeof(mz_jit_state));
05323 }
05324 
05325 static int mark_jit_state_MARK(void *p) {
05326   mz_jit_state *j = (mz_jit_state *)p;
05327   gcMARK(j->mappings);
05328   gcMARK(j->self_data);
05329   return
05330   gcBYTES_TO_WORDS(sizeof(mz_jit_state));
05331 }
05332 
05333 static int mark_jit_state_FIXUP(void *p) {
05334   mz_jit_state *j = (mz_jit_state *)p;
05335   gcFIXUP(j->mappings);
05336   gcFIXUP(j->self_data);
05337   return
05338   gcBYTES_TO_WORDS(sizeof(mz_jit_state));
05339 }
05340 
05341 #define mark_jit_state_IS_ATOMIC 0
05342 #define mark_jit_state_IS_CONST_SIZE 1
05343 
05344 
05345 static int native_unclosed_proc_SIZE(void *p) {
05346   return
05347   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
05348 }
05349 
05350 static int native_unclosed_proc_MARK(void *p) {
05351   Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
05352   int i;
05353 
05354   gcMARK(d->u2.name);
05355   if (d->retained) {
05356     for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) {
05357       gcMARK(d->retained[i]);
05358     }
05359   }
05360   if (d->closure_size < 0) {
05361     gcMARK(d->u.arities);
05362   }
05363 
05364   return
05365   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
05366 }
05367 
05368 static int native_unclosed_proc_FIXUP(void *p) {
05369   Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
05370   int i;
05371 
05372   gcFIXUP(d->u2.name);
05373   if (d->retained) {
05374     for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) {
05375       gcFIXUP(d->retained[i]);
05376     }
05377   }
05378   if (d->closure_size < 0) {
05379     gcFIXUP(d->u.arities);
05380   }
05381 
05382   return
05383   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
05384 }
05385 
05386 #define native_unclosed_proc_IS_ATOMIC 0
05387 #define native_unclosed_proc_IS_CONST_SIZE 1
05388 
05389 
05390 static int native_unclosed_proc_plus_case_SIZE(void *p) {
05391   return
05392   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
05393 }
05394 
05395 static int native_unclosed_proc_plus_case_MARK(void *p) {
05396   Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p;
05397 
05398   native_unclosed_proc_MARK(p);
05399   gcMARK(d->case_lam);
05400 
05401   return
05402   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
05403 }
05404 
05405 static int native_unclosed_proc_plus_case_FIXUP(void *p) {
05406   Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p;
05407 
05408   native_unclosed_proc_FIXUP(p);
05409   gcFIXUP(d->case_lam);
05410 
05411   return
05412   gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
05413 }
05414 
05415 #define native_unclosed_proc_plus_case_IS_ATOMIC 0
05416 #define native_unclosed_proc_plus_case_IS_CONST_SIZE 1
05417 
05418 
05419 #endif  /* JIT */
05420 
05421 /**********************************************************************/
05422 
05423 #define GC_REG_TRAV(type, base) GC_register_traversers(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC)