1/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */ 2 3static int mark_parameterization_SIZE(void *p, struct NewGC *gc) { 4#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 5 gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) 6 + ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*)))); 7#else 8 return 0; 9#endif 10} 11 12static int mark_parameterization_MARK(void *p, struct NewGC *gc) { 13#ifndef GC_NO_MARK_PROCEDURE_NEEDED 14 Scheme_Parameterization *c = (Scheme_Parameterization *)p; 15 int i; 16 17 for (i = max_configs; i--; ) { 18 gcMARK2(c->prims[i], gc); 19 } 20 gcMARK2(c->extensions, gc); 21 22# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 23 return 0; 24# else 25 return 26 gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) 27 + ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*)))); 28# endif 29#endif 30} 31 32static int mark_parameterization_FIXUP(void *p, struct NewGC *gc) { 33#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 34 Scheme_Parameterization *c = (Scheme_Parameterization *)p; 35 int i; 36 37 for (i = max_configs; i--; ) { 38 gcFIXUP2(c->prims[i], gc); 39 } 40 gcFIXUP2(c->extensions, gc); 41 42# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 43 return 0; 44# else 45 return 46 gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization) 47 + ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*)))); 48# endif 49#endif 50} 51 52#define mark_parameterization_IS_ATOMIC 0 53#define mark_parameterization_IS_CONST_SIZE 0 54 55 56static int mark_config_SIZE(void *p, struct NewGC *gc) { 57#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 58 gcBYTES_TO_WORDS(sizeof(Scheme_Config)); 59#else 60 return 0; 61#endif 62} 63 64static int mark_config_MARK(void *p, struct NewGC *gc) { 65#ifndef GC_NO_MARK_PROCEDURE_NEEDED 66 Scheme_Config *config = (Scheme_Config *)p; 67 gcMARK2(config->ht, gc); 68 gcMARK2(config->root, gc); 69# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 70 return 0; 71# else 72 return 73 gcBYTES_TO_WORDS(sizeof(Scheme_Config)); 74# endif 75#endif 76} 77 78static int mark_config_FIXUP(void *p, struct NewGC *gc) { 79#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 80 Scheme_Config *config = (Scheme_Config *)p; 81 gcFIXUP2(config->ht, gc); 82 gcFIXUP2(config->root, gc); 83# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 84 return 0; 85# else 86 return 87 gcBYTES_TO_WORDS(sizeof(Scheme_Config)); 88# endif 89#endif 90} 91 92#define mark_config_IS_ATOMIC 0 93#define mark_config_IS_CONST_SIZE 1 94 95 96static int mark_will_executor_val_SIZE(void *p, struct NewGC *gc) { 97#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 98 gcBYTES_TO_WORDS(sizeof(WillExecutor)); 99#else 100 return 0; 101#endif 102} 103 104static int mark_will_executor_val_MARK(void *p, struct NewGC *gc) { 105#ifndef GC_NO_MARK_PROCEDURE_NEEDED 106 WillExecutor *e = (WillExecutor *)p; 107 108 gcMARK2(e->sema, gc); 109 gcMARK2(e->first, gc); 110 gcMARK2(e->last, gc); 111 112# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 113 return 0; 114# else 115 return 116 gcBYTES_TO_WORDS(sizeof(WillExecutor)); 117# endif 118#endif 119} 120 121static int mark_will_executor_val_FIXUP(void *p, struct NewGC *gc) { 122#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 123 WillExecutor *e = (WillExecutor *)p; 124 125 gcFIXUP2(e->sema, gc); 126 gcFIXUP2(e->first, gc); 127 gcFIXUP2(e->last, gc); 128 129# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 130 return 0; 131# else 132 return 133 gcBYTES_TO_WORDS(sizeof(WillExecutor)); 134# endif 135#endif 136} 137 138#define mark_will_executor_val_IS_ATOMIC 0 139#define mark_will_executor_val_IS_CONST_SIZE 1 140 141 142static int mark_custodian_val_SIZE(void *p, struct NewGC *gc) { 143#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 144 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); 145#else 146 return 0; 147#endif 148} 149 150static int mark_custodian_val_MARK(void *p, struct NewGC *gc) { 151#ifndef GC_NO_MARK_PROCEDURE_NEEDED 152 Scheme_Custodian *m = (Scheme_Custodian *)p; 153 154 gcMARK2(m->boxes, gc); 155 gcMARK2(m->mrefs, gc); 156 gcMARK2(m->closers, gc); 157 gcMARK2(m->data, gc); 158 gcMARK2(m->data_ptr, gc); 159 gcMARK2(m->post_callbacks, gc); 160 161 gcMARK2(m->parent, gc); 162 gcMARK2(m->sibling, gc); 163 gcMARK2(m->children, gc); 164 165 gcMARK2(m->global_next, gc); 166 gcMARK2(m->global_prev, gc); 167 168 gcMARK2(m->cust_boxes, gc); 169 170# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 171 return 0; 172# else 173 return 174 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); 175# endif 176#endif 177} 178 179static int mark_custodian_val_FIXUP(void *p, struct NewGC *gc) { 180#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 181 Scheme_Custodian *m = (Scheme_Custodian *)p; 182 183 gcFIXUP2(m->boxes, gc); 184 gcFIXUP2(m->mrefs, gc); 185 gcFIXUP2(m->closers, gc); 186 gcFIXUP2(m->data, gc); 187 gcFIXUP2(m->data_ptr, gc); 188 gcFIXUP2(m->post_callbacks, gc); 189 190 gcFIXUP2(m->parent, gc); 191 gcFIXUP2(m->sibling, gc); 192 gcFIXUP2(m->children, gc); 193 194 gcFIXUP2(m->global_next, gc); 195 gcFIXUP2(m->global_prev, gc); 196 197 gcFIXUP2(m->cust_boxes, gc); 198 199# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 200 return 0; 201# else 202 return 203 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian)); 204# endif 205#endif 206} 207 208#define mark_custodian_val_IS_ATOMIC 0 209#define mark_custodian_val_IS_CONST_SIZE 1 210 211 212static int mark_custodian_box_val_SIZE(void *p, struct NewGC *gc) { 213#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 214 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box)); 215#else 216 return 0; 217#endif 218} 219 220static int mark_custodian_box_val_MARK(void *p, struct NewGC *gc) { 221#ifndef GC_NO_MARK_PROCEDURE_NEEDED 222 Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p; 223 int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down; 224 225 gcMARK2(b->cust, gc); 226 if (!sd) { 227 gcMARK2(b->v, gc); 228 } 229 230# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 231 return 0; 232# else 233 return 234 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box)); 235# endif 236#endif 237} 238 239static int mark_custodian_box_val_FIXUP(void *p, struct NewGC *gc) { 240#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 241 Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p; 242 int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down; 243 244 gcFIXUP2(b->cust, gc); 245 if (!sd) { 246 gcFIXUP2(b->v, gc); 247 } 248 249# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 250 return 0; 251# else 252 return 253 gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box)); 254# endif 255#endif 256} 257 258#define mark_custodian_box_val_IS_ATOMIC 0 259#define mark_custodian_box_val_IS_CONST_SIZE 1 260 261 262static int mark_thread_hop_SIZE(void *p, struct NewGC *gc) { 263#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 264 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); 265#else 266 return 0; 267#endif 268} 269 270static int mark_thread_hop_MARK(void *p, struct NewGC *gc) { 271#ifndef GC_NO_MARK_PROCEDURE_NEEDED 272 Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p; 273 274 gcMARK2(hop->p, gc); 275 276# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 277 return 0; 278# else 279 return 280 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); 281# endif 282#endif 283} 284 285static int mark_thread_hop_FIXUP(void *p, struct NewGC *gc) { 286#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 287 Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p; 288 289 gcFIXUP2(hop->p, gc); 290 291# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 292 return 0; 293# else 294 return 295 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop)); 296# endif 297#endif 298} 299 300#define mark_thread_hop_IS_ATOMIC 0 301#define mark_thread_hop_IS_CONST_SIZE 1 302 303 304static int mark_param_data_SIZE(void *p, struct NewGC *gc) { 305#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 306 gcBYTES_TO_WORDS(sizeof(ParamData)); 307#else 308 return 0; 309#endif 310} 311 312static int mark_param_data_MARK(void *p, struct NewGC *gc) { 313#ifndef GC_NO_MARK_PROCEDURE_NEEDED 314 ParamData *d = (ParamData *)p; 315 316 gcMARK2(d->key, gc); 317 gcMARK2(d->guard, gc); 318 gcMARK2(d->extract_guard, gc); 319 gcMARK2(d->defcell, gc); 320 321# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 322 return 0; 323# else 324 return 325 gcBYTES_TO_WORDS(sizeof(ParamData)); 326# endif 327#endif 328} 329 330static int mark_param_data_FIXUP(void *p, struct NewGC *gc) { 331#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 332 ParamData *d = (ParamData *)p; 333 334 gcFIXUP2(d->key, gc); 335 gcFIXUP2(d->guard, gc); 336 gcFIXUP2(d->extract_guard, gc); 337 gcFIXUP2(d->defcell, gc); 338 339# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 340 return 0; 341# else 342 return 343 gcBYTES_TO_WORDS(sizeof(ParamData)); 344# endif 345#endif 346} 347 348#define mark_param_data_IS_ATOMIC 0 349#define mark_param_data_IS_CONST_SIZE 1 350 351 352static int mark_will_SIZE(void *p, struct NewGC *gc) { 353#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 354 gcBYTES_TO_WORDS(sizeof(ActiveWill)); 355#else 356 return 0; 357#endif 358} 359 360static int mark_will_MARK(void *p, struct NewGC *gc) { 361#ifndef GC_NO_MARK_PROCEDURE_NEEDED 362 ActiveWill *w = (ActiveWill *)p; 363 364 gcMARK2(w->o, gc); 365 gcMARK2(w->proc, gc); 366 gcMARK2(w->w, gc); 367 gcMARK2(w->next, gc); 368 369# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 370 return 0; 371# else 372 return 373 gcBYTES_TO_WORDS(sizeof(ActiveWill)); 374# endif 375#endif 376} 377 378static int mark_will_FIXUP(void *p, struct NewGC *gc) { 379#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 380 ActiveWill *w = (ActiveWill *)p; 381 382 gcFIXUP2(w->o, gc); 383 gcFIXUP2(w->proc, gc); 384 gcFIXUP2(w->w, gc); 385 gcFIXUP2(w->next, gc); 386 387# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 388 return 0; 389# else 390 return 391 gcBYTES_TO_WORDS(sizeof(ActiveWill)); 392# endif 393#endif 394} 395 396#define mark_will_IS_ATOMIC 0 397#define mark_will_IS_CONST_SIZE 1 398 399 400static int mark_evt_SIZE(void *p, struct NewGC *gc) { 401#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 402 gcBYTES_TO_WORDS(sizeof(Evt)); 403#else 404 return 0; 405#endif 406} 407 408static int mark_evt_MARK(void *p, struct NewGC *gc) { 409#ifndef GC_NO_MARK_PROCEDURE_NEEDED 410# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 411 return 0; 412# else 413 return 414 gcBYTES_TO_WORDS(sizeof(Evt)); 415# endif 416#endif 417} 418 419static int mark_evt_FIXUP(void *p, struct NewGC *gc) { 420#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 421# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 422 return 0; 423# else 424 return 425 gcBYTES_TO_WORDS(sizeof(Evt)); 426# endif 427#endif 428} 429 430#define mark_evt_IS_ATOMIC 1 431#define mark_evt_IS_CONST_SIZE 1 432 433 434static int mark_syncing_SIZE(void *p, struct NewGC *gc) { 435#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 436 gcBYTES_TO_WORDS(sizeof(Syncing)); 437#else 438 return 0; 439#endif 440} 441 442static int mark_syncing_MARK(void *p, struct NewGC *gc) { 443#ifndef GC_NO_MARK_PROCEDURE_NEEDED 444 Syncing *w = (Syncing *)p; 445 446 gcMARK2(w->set, gc); 447 gcMARK2(w->wrapss, gc); 448 gcMARK2(w->nackss, gc); 449 gcMARK2(w->reposts, gc); 450 gcMARK2(w->accepts, gc); 451 gcMARK2(w->disable_break, gc); 452 gcMARK2(w->thread, gc); 453 454# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 455 return 0; 456# else 457 return 458 gcBYTES_TO_WORDS(sizeof(Syncing)); 459# endif 460#endif 461} 462 463static int mark_syncing_FIXUP(void *p, struct NewGC *gc) { 464#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 465 Syncing *w = (Syncing *)p; 466 467 gcFIXUP2(w->set, gc); 468 gcFIXUP2(w->wrapss, gc); 469 gcFIXUP2(w->nackss, gc); 470 gcFIXUP2(w->reposts, gc); 471 gcFIXUP2(w->accepts, gc); 472 gcFIXUP2(w->disable_break, gc); 473 gcFIXUP2(w->thread, gc); 474 475# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 476 return 0; 477# else 478 return 479 gcBYTES_TO_WORDS(sizeof(Syncing)); 480# endif 481#endif 482} 483 484#define mark_syncing_IS_ATOMIC 0 485#define mark_syncing_IS_CONST_SIZE 1 486 487 488static int mark_evt_set_SIZE(void *p, struct NewGC *gc) { 489#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 490 gcBYTES_TO_WORDS(sizeof(Evt_Set)); 491#else 492 return 0; 493#endif 494} 495 496static int mark_evt_set_MARK(void *p, struct NewGC *gc) { 497#ifndef GC_NO_MARK_PROCEDURE_NEEDED 498 Evt_Set *w = (Evt_Set *)p; 499 500 gcMARK2(w->ws, gc); 501 gcMARK2(w->argv, gc); 502 503# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 504 return 0; 505# else 506 return 507 gcBYTES_TO_WORDS(sizeof(Evt_Set)); 508# endif 509#endif 510} 511 512static int mark_evt_set_FIXUP(void *p, struct NewGC *gc) { 513#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 514 Evt_Set *w = (Evt_Set *)p; 515 516 gcFIXUP2(w->ws, gc); 517 gcFIXUP2(w->argv, gc); 518 519# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 520 return 0; 521# else 522 return 523 gcBYTES_TO_WORDS(sizeof(Evt_Set)); 524# endif 525#endif 526} 527 528#define mark_evt_set_IS_ATOMIC 0 529#define mark_evt_set_IS_CONST_SIZE 1 530 531 532static int mark_thread_set_SIZE(void *p, struct NewGC *gc) { 533#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 534 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); 535#else 536 return 0; 537#endif 538} 539 540static int mark_thread_set_MARK(void *p, struct NewGC *gc) { 541#ifndef GC_NO_MARK_PROCEDURE_NEEDED 542 Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p; 543 544 gcMARK2(ts->parent, gc); 545 gcMARK2(ts->first, gc); 546 gcMARK2(ts->next, gc); 547 gcMARK2(ts->prev, gc); 548 gcMARK2(ts->search_start, gc); 549 gcMARK2(ts->current, gc); 550 551# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 552 return 0; 553# else 554 return 555 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); 556# endif 557#endif 558} 559 560static int mark_thread_set_FIXUP(void *p, struct NewGC *gc) { 561#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 562 Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p; 563 564 gcFIXUP2(ts->parent, gc); 565 gcFIXUP2(ts->first, gc); 566 gcFIXUP2(ts->next, gc); 567 gcFIXUP2(ts->prev, gc); 568 gcFIXUP2(ts->search_start, gc); 569 gcFIXUP2(ts->current, gc); 570 571# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 572 return 0; 573# else 574 return 575 gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set)); 576# endif 577#endif 578} 579 580#define mark_thread_set_IS_ATOMIC 0 581#define mark_thread_set_IS_CONST_SIZE 1 582 583 584static int mark_thread_cell_SIZE(void *p, struct NewGC *gc) { 585#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 586 gcBYTES_TO_WORDS(sizeof(Thread_Cell)); 587#else 588 return 0; 589#endif 590} 591 592static int mark_thread_cell_MARK(void *p, struct NewGC *gc) { 593#ifndef GC_NO_MARK_PROCEDURE_NEEDED 594 Thread_Cell *c = (Thread_Cell *)p; 595 596 gcMARK2(c->def_val, gc); 597 598# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 599 return 0; 600# else 601 return 602 gcBYTES_TO_WORDS(sizeof(Thread_Cell)); 603# endif 604#endif 605} 606 607static int mark_thread_cell_FIXUP(void *p, struct NewGC *gc) { 608#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 609 Thread_Cell *c = (Thread_Cell *)p; 610 611 gcFIXUP2(c->def_val, gc); 612 613# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 614 return 0; 615# else 616 return 617 gcBYTES_TO_WORDS(sizeof(Thread_Cell)); 618# endif 619#endif 620} 621 622#define mark_thread_cell_IS_ATOMIC 0 623#define mark_thread_cell_IS_CONST_SIZE 1 624 625 626static int mark_plumber_SIZE(void *p, struct NewGC *gc) { 627#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 628 gcBYTES_TO_WORDS(sizeof(Scheme_Plumber)); 629#else 630 return 0; 631#endif 632} 633 634static int mark_plumber_MARK(void *p, struct NewGC *gc) { 635#ifndef GC_NO_MARK_PROCEDURE_NEEDED 636 Scheme_Plumber *pl = (Scheme_Plumber *)p; 637 638 gcMARK2(pl->handles, gc); 639 gcMARK2(pl->weak_handles, gc); 640 641# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 642 return 0; 643# else 644 return 645 gcBYTES_TO_WORDS(sizeof(Scheme_Plumber)); 646# endif 647#endif 648} 649 650static int mark_plumber_FIXUP(void *p, struct NewGC *gc) { 651#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 652 Scheme_Plumber *pl = (Scheme_Plumber *)p; 653 654 gcFIXUP2(pl->handles, gc); 655 gcFIXUP2(pl->weak_handles, gc); 656 657# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 658 return 0; 659# else 660 return 661 gcBYTES_TO_WORDS(sizeof(Scheme_Plumber)); 662# endif 663#endif 664} 665 666#define mark_plumber_IS_ATOMIC 0 667#define mark_plumber_IS_CONST_SIZE 1 668 669 670