1/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */ 2 3static int variable_obj_SIZE(void *p, struct NewGC *gc) { 4#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 5 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); 6#else 7 return 0; 8#endif 9} 10 11static int variable_obj_MARK(void *p, struct NewGC *gc) { 12#ifndef GC_NO_MARK_PROCEDURE_NEEDED 13 Scheme_Bucket *b = (Scheme_Bucket *)p; 14 15 gcMARK2(b->key, gc); 16 gcMARK2(b->val, gc); 17 gcMARK2(((Scheme_Bucket_With_Home *)b)->home_link, gc); 18 19# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 20 return 0; 21# else 22 return 23 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); 24# endif 25#endif 26} 27 28static int variable_obj_FIXUP(void *p, struct NewGC *gc) { 29#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 30 Scheme_Bucket *b = (Scheme_Bucket *)p; 31 32 gcFIXUP2(b->key, gc); 33 gcFIXUP2(b->val, gc); 34 gcFIXUP2(((Scheme_Bucket_With_Home *)b)->home_link, gc); 35 36# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 37 return 0; 38# else 39 return 40 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_With_Home)); 41# endif 42#endif 43} 44 45#define variable_obj_IS_ATOMIC 0 46#define variable_obj_IS_CONST_SIZE 1 47 48 49static int bucket_obj_SIZE(void *p, struct NewGC *gc) { 50#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 51 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); 52#else 53 return 0; 54#endif 55} 56 57static int bucket_obj_MARK(void *p, struct NewGC *gc) { 58#ifndef GC_NO_MARK_PROCEDURE_NEEDED 59 Scheme_Bucket *b = (Scheme_Bucket *)p; 60 61 gcMARK2(b->key, gc); 62 gcMARK2(b->val, gc); 63 64# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 65 return 0; 66# else 67 return 68 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); 69# endif 70#endif 71} 72 73static int bucket_obj_FIXUP(void *p, struct NewGC *gc) { 74#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 75 Scheme_Bucket *b = (Scheme_Bucket *)p; 76 77 gcFIXUP2(b->key, gc); 78 gcFIXUP2(b->val, gc); 79 80# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 81 return 0; 82# else 83 return 84 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket)); 85# endif 86#endif 87} 88 89#define bucket_obj_IS_ATOMIC 0 90#define bucket_obj_IS_CONST_SIZE 1 91 92 93static int local_obj_SIZE(void *p, struct NewGC *gc) { 94#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 95 gcBYTES_TO_WORDS(sizeof(Scheme_Local)); 96#else 97 return 0; 98#endif 99} 100 101static int local_obj_MARK(void *p, struct NewGC *gc) { 102#ifndef GC_NO_MARK_PROCEDURE_NEEDED 103# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 104 return 0; 105# else 106 return 107 gcBYTES_TO_WORDS(sizeof(Scheme_Local)); 108# endif 109#endif 110} 111 112static int local_obj_FIXUP(void *p, struct NewGC *gc) { 113#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 114# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 115 return 0; 116# else 117 return 118 gcBYTES_TO_WORDS(sizeof(Scheme_Local)); 119# endif 120#endif 121} 122 123#define local_obj_IS_ATOMIC 1 124#define local_obj_IS_CONST_SIZE 1 125 126 127static int toplevel_obj_SIZE(void *p, struct NewGC *gc) { 128#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 129 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 130#else 131 return 0; 132#endif 133} 134 135static int toplevel_obj_MARK(void *p, struct NewGC *gc) { 136#ifndef GC_NO_MARK_PROCEDURE_NEEDED 137# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 138 return 0; 139# else 140 return 141 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 142# endif 143#endif 144} 145 146static int toplevel_obj_FIXUP(void *p, struct NewGC *gc) { 147#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 148# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 149 return 0; 150# else 151 return 152 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 153# endif 154#endif 155} 156 157#define toplevel_obj_IS_ATOMIC 1 158#define toplevel_obj_IS_CONST_SIZE 1 159 160 161static int static_toplevel_obj_SIZE(void *p, struct NewGC *gc) { 162#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 163 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 164#else 165 return 0; 166#endif 167} 168 169static int static_toplevel_obj_MARK(void *p, struct NewGC *gc) { 170#ifndef GC_NO_MARK_PROCEDURE_NEEDED 171 gcMARK2(SCHEME_STATIC_TOPLEVEL_PREFIX(p), gc); 172# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 173 return 0; 174# else 175 return 176 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 177# endif 178#endif 179} 180 181static int static_toplevel_obj_FIXUP(void *p, struct NewGC *gc) { 182#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 183 gcFIXUP2(SCHEME_STATIC_TOPLEVEL_PREFIX(p), gc); 184# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 185 return 0; 186# else 187 return 188 gcBYTES_TO_WORDS(sizeof(Scheme_Toplevel)); 189# endif 190#endif 191} 192 193#define static_toplevel_obj_IS_ATOMIC 0 194#define static_toplevel_obj_IS_CONST_SIZE 1 195 196 197static int cpointer_obj_SIZE(void *p, struct NewGC *gc) { 198#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 199 (SCHEME_CPTR_HAS_OFFSET(p) 200 ? gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)) 201 : gcBYTES_TO_WORDS(sizeof(Scheme_Cptr))); 202#else 203 return 0; 204#endif 205} 206 207static int cpointer_obj_MARK(void *p, struct NewGC *gc) { 208#ifndef GC_NO_MARK_PROCEDURE_NEEDED 209 if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { 210 gcMARK2(SCHEME_CPTR_VAL(p), gc); 211 } 212 gcMARK2(SCHEME_CPTR_TYPE(p), gc); 213# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 214 return 0; 215# else 216 return 217 (SCHEME_CPTR_HAS_OFFSET(p) 218 ? gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)) 219 : gcBYTES_TO_WORDS(sizeof(Scheme_Cptr))); 220# endif 221#endif 222} 223 224static int cpointer_obj_FIXUP(void *p, struct NewGC *gc) { 225#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 226 if (!(SCHEME_CPTR_FLAGS(p) & 0x1)) { 227 gcFIXUP2(SCHEME_CPTR_VAL(p), gc); 228 } 229 gcFIXUP2(SCHEME_CPTR_TYPE(p), gc); 230# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 231 return 0; 232# else 233 return 234 (SCHEME_CPTR_HAS_OFFSET(p) 235 ? gcBYTES_TO_WORDS(sizeof(Scheme_Offset_Cptr)) 236 : gcBYTES_TO_WORDS(sizeof(Scheme_Cptr))); 237# endif 238#endif 239} 240 241#define cpointer_obj_IS_ATOMIC 0 242#define cpointer_obj_IS_CONST_SIZE 0 243 244 245static int twoptr_obj_SIZE(void *p, struct NewGC *gc) { 246#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 247 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 248#else 249 return 0; 250#endif 251} 252 253static int twoptr_obj_MARK(void *p, struct NewGC *gc) { 254#ifndef GC_NO_MARK_PROCEDURE_NEEDED 255 gcMARK2(SCHEME_PTR1_VAL((Scheme_Object *)p), gc); 256 gcMARK2(SCHEME_PTR2_VAL((Scheme_Object *)p), gc); 257# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 258 return 0; 259# else 260 return 261 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 262# endif 263#endif 264} 265 266static int twoptr_obj_FIXUP(void *p, struct NewGC *gc) { 267#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 268 gcFIXUP2(SCHEME_PTR1_VAL((Scheme_Object *)p), gc); 269 gcFIXUP2(SCHEME_PTR2_VAL((Scheme_Object *)p), gc); 270# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 271 return 0; 272# else 273 return 274 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 275# endif 276#endif 277} 278 279#define twoptr_obj_IS_ATOMIC 0 280#define twoptr_obj_IS_CONST_SIZE 1 281 282 283static int iptr_obj_SIZE(void *p, struct NewGC *gc) { 284#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 285 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 286#else 287 return 0; 288#endif 289} 290 291static int iptr_obj_MARK(void *p, struct NewGC *gc) { 292#ifndef GC_NO_MARK_PROCEDURE_NEEDED 293 gcMARK2(SCHEME_IPTR_VAL((Scheme_Object *)p), gc); 294# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 295 return 0; 296# else 297 return 298 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 299# endif 300#endif 301} 302 303static int iptr_obj_FIXUP(void *p, struct NewGC *gc) { 304#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 305 gcFIXUP2(SCHEME_IPTR_VAL((Scheme_Object *)p), gc); 306# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 307 return 0; 308# else 309 return 310 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 311# endif 312#endif 313} 314 315#define iptr_obj_IS_ATOMIC 0 316#define iptr_obj_IS_CONST_SIZE 1 317 318 319static int small_object_SIZE(void *p, struct NewGC *gc) { 320#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 321 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 322#else 323 return 0; 324#endif 325} 326 327static int small_object_MARK(void *p, struct NewGC *gc) { 328#ifndef GC_NO_MARK_PROCEDURE_NEEDED 329 gcMARK2(((Scheme_Small_Object *)p)->u.ptr_value, gc); 330 331# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 332 return 0; 333# else 334 return 335 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 336# endif 337#endif 338} 339 340static int small_object_FIXUP(void *p, struct NewGC *gc) { 341#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 342 gcFIXUP2(((Scheme_Small_Object *)p)->u.ptr_value, gc); 343 344# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 345 return 0; 346# else 347 return 348 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 349# endif 350#endif 351} 352 353#define small_object_IS_ATOMIC 0 354#define small_object_IS_CONST_SIZE 1 355 356 357static int small_atomic_obj_SIZE(void *p, struct NewGC *gc) { 358#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 359 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 360#else 361 return 0; 362#endif 363} 364 365static int small_atomic_obj_MARK(void *p, struct NewGC *gc) { 366#ifndef GC_NO_MARK_PROCEDURE_NEEDED 367# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 368 return 0; 369# else 370 return 371 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 372# endif 373#endif 374} 375 376static int small_atomic_obj_FIXUP(void *p, struct NewGC *gc) { 377#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 378# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 379 return 0; 380# else 381 return 382 gcBYTES_TO_WORDS(sizeof(Scheme_Small_Object)); 383# endif 384#endif 385} 386 387#define small_atomic_obj_IS_ATOMIC 1 388#define small_atomic_obj_IS_CONST_SIZE 1 389 390 391static int app_rec_SIZE(void *p, struct NewGC *gc) { 392#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 393 Scheme_App_Rec *r = (Scheme_App_Rec *)p; 394 395 gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 396 + ((r->num_args + 1 - mzFLEX_DELTA) * sizeof(Scheme_Object *)) 397 + ((r->num_args + 1) * sizeof(char)))); 398#else 399 return 0; 400#endif 401} 402 403static int app_rec_MARK(void *p, struct NewGC *gc) { 404#ifndef GC_NO_MARK_PROCEDURE_NEEDED 405 Scheme_App_Rec *r = (Scheme_App_Rec *)p; 406 407 int i = r->num_args + 1; 408 while (i--) 409 gcMARK2(r->args[i], gc); 410 411# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 412 return 0; 413# else 414 return 415 gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 416 + ((r->num_args + 1 - mzFLEX_DELTA) * sizeof(Scheme_Object *)) 417 + ((r->num_args + 1) * sizeof(char)))); 418# endif 419#endif 420} 421 422static int app_rec_FIXUP(void *p, struct NewGC *gc) { 423#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 424 Scheme_App_Rec *r = (Scheme_App_Rec *)p; 425 426 int i = r->num_args + 1; 427 while (i--) 428 gcFIXUP2(r->args[i], gc); 429 430# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 431 return 0; 432# else 433 return 434 gcBYTES_TO_WORDS((sizeof(Scheme_App_Rec) 435 + ((r->num_args + 1 - mzFLEX_DELTA) * sizeof(Scheme_Object *)) 436 + ((r->num_args + 1) * sizeof(char)))); 437# endif 438#endif 439} 440 441#define app_rec_IS_ATOMIC 0 442#define app_rec_IS_CONST_SIZE 0 443 444 445static int app2_rec_SIZE(void *p, struct NewGC *gc) { 446#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 447 gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); 448#else 449 return 0; 450#endif 451} 452 453static int app2_rec_MARK(void *p, struct NewGC *gc) { 454#ifndef GC_NO_MARK_PROCEDURE_NEEDED 455 Scheme_App2_Rec *r = (Scheme_App2_Rec *)p; 456 gcMARK2(r->rator, gc); 457 gcMARK2(r->rand, gc); 458 459# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 460 return 0; 461# else 462 return 463 gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); 464# endif 465#endif 466} 467 468static int app2_rec_FIXUP(void *p, struct NewGC *gc) { 469#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 470 Scheme_App2_Rec *r = (Scheme_App2_Rec *)p; 471 gcFIXUP2(r->rator, gc); 472 gcFIXUP2(r->rand, gc); 473 474# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 475 return 0; 476# else 477 return 478 gcBYTES_TO_WORDS(sizeof(Scheme_App2_Rec)); 479# endif 480#endif 481} 482 483#define app2_rec_IS_ATOMIC 0 484#define app2_rec_IS_CONST_SIZE 1 485 486 487static int app3_rec_SIZE(void *p, struct NewGC *gc) { 488#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 489 gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); 490#else 491 return 0; 492#endif 493} 494 495static int app3_rec_MARK(void *p, struct NewGC *gc) { 496#ifndef GC_NO_MARK_PROCEDURE_NEEDED 497 Scheme_App3_Rec *r = (Scheme_App3_Rec *)p; 498 gcMARK2(r->rator, gc); 499 gcMARK2(r->rand1, gc); 500 gcMARK2(r->rand2, gc); 501 502# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 503 return 0; 504# else 505 return 506 gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); 507# endif 508#endif 509} 510 511static int app3_rec_FIXUP(void *p, struct NewGC *gc) { 512#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 513 Scheme_App3_Rec *r = (Scheme_App3_Rec *)p; 514 gcFIXUP2(r->rator, gc); 515 gcFIXUP2(r->rand1, gc); 516 gcFIXUP2(r->rand2, gc); 517 518# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 519 return 0; 520# else 521 return 522 gcBYTES_TO_WORDS(sizeof(Scheme_App3_Rec)); 523# endif 524#endif 525} 526 527#define app3_rec_IS_ATOMIC 0 528#define app3_rec_IS_CONST_SIZE 1 529 530 531static int seq_rec_SIZE(void *p, struct NewGC *gc) { 532#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 533 Scheme_Sequence *s = (Scheme_Sequence *)p; 534 535 gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) 536 + ((s->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 537#else 538 return 0; 539#endif 540} 541 542static int seq_rec_MARK(void *p, struct NewGC *gc) { 543#ifndef GC_NO_MARK_PROCEDURE_NEEDED 544 Scheme_Sequence *s = (Scheme_Sequence *)p; 545 546 int i = s->count; 547 while (i--) 548 gcMARK2(s->array[i], gc); 549 550# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 551 return 0; 552# else 553 return 554 gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) 555 + ((s->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 556# endif 557#endif 558} 559 560static int seq_rec_FIXUP(void *p, struct NewGC *gc) { 561#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 562 Scheme_Sequence *s = (Scheme_Sequence *)p; 563 564 int i = s->count; 565 while (i--) 566 gcFIXUP2(s->array[i], gc); 567 568# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 569 return 0; 570# else 571 return 572 gcBYTES_TO_WORDS((sizeof(Scheme_Sequence) 573 + ((s->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 574# endif 575#endif 576} 577 578#define seq_rec_IS_ATOMIC 0 579#define seq_rec_IS_CONST_SIZE 0 580 581 582static int branch_rec_SIZE(void *p, struct NewGC *gc) { 583#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 584 gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); 585#else 586 return 0; 587#endif 588} 589 590static int branch_rec_MARK(void *p, struct NewGC *gc) { 591#ifndef GC_NO_MARK_PROCEDURE_NEEDED 592 Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p; 593 594 gcMARK2(b->test, gc); 595 gcMARK2(b->tbranch, gc); 596 gcMARK2(b->fbranch, gc); 597 598# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 599 return 0; 600# else 601 return 602 gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); 603# endif 604#endif 605} 606 607static int branch_rec_FIXUP(void *p, struct NewGC *gc) { 608#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 609 Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)p; 610 611 gcFIXUP2(b->test, gc); 612 gcFIXUP2(b->tbranch, gc); 613 gcFIXUP2(b->fbranch, gc); 614 615# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 616 return 0; 617# else 618 return 619 gcBYTES_TO_WORDS(sizeof(Scheme_Branch_Rec)); 620# endif 621#endif 622} 623 624#define branch_rec_IS_ATOMIC 0 625#define branch_rec_IS_CONST_SIZE 1 626 627 628static int unclosed_proc_SIZE(void *p, struct NewGC *gc) { 629#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 630 gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); 631#else 632 return 0; 633#endif 634} 635 636static int unclosed_proc_MARK(void *p, struct NewGC *gc) { 637#ifndef GC_NO_MARK_PROCEDURE_NEEDED 638 Scheme_Lambda *d = (Scheme_Lambda *)p; 639 640 gcMARK2(d->name, gc); 641 gcMARK2(d->body, gc); 642 gcMARK2(d->closure_map, gc); /* covers `ir_info` */ 643 gcMARK2(d->tl_map, gc); 644#ifdef MZ_USE_JIT 645 gcMARK2(d->u.native_code, gc); 646 gcMARK2(d->context, gc); 647#endif 648 649# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 650 return 0; 651# else 652 return 653 gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); 654# endif 655#endif 656} 657 658static int unclosed_proc_FIXUP(void *p, struct NewGC *gc) { 659#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 660 Scheme_Lambda *d = (Scheme_Lambda *)p; 661 662 gcFIXUP2(d->name, gc); 663 gcFIXUP2(d->body, gc); 664 gcFIXUP2(d->closure_map, gc); /* covers `ir_info` */ 665 gcFIXUP2(d->tl_map, gc); 666#ifdef MZ_USE_JIT 667 gcFIXUP2(d->u.native_code, gc); 668 gcFIXUP2(d->context, gc); 669#endif 670 671# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 672 return 0; 673# else 674 return 675 gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); 676# endif 677#endif 678} 679 680#define unclosed_proc_IS_ATOMIC 0 681#define unclosed_proc_IS_CONST_SIZE 1 682 683 684static int let_value_SIZE(void *p, struct NewGC *gc) { 685#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 686 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); 687#else 688 return 0; 689#endif 690} 691 692static int let_value_MARK(void *p, struct NewGC *gc) { 693#ifndef GC_NO_MARK_PROCEDURE_NEEDED 694 Scheme_Let_Value *l = (Scheme_Let_Value *)p; 695 696 gcMARK2(l->value, gc); 697 gcMARK2(l->body, gc); 698 699# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 700 return 0; 701# else 702 return 703 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); 704# endif 705#endif 706} 707 708static int let_value_FIXUP(void *p, struct NewGC *gc) { 709#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 710 Scheme_Let_Value *l = (Scheme_Let_Value *)p; 711 712 gcFIXUP2(l->value, gc); 713 gcFIXUP2(l->body, gc); 714 715# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 716 return 0; 717# else 718 return 719 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Value)); 720# endif 721#endif 722} 723 724#define let_value_IS_ATOMIC 0 725#define let_value_IS_CONST_SIZE 1 726 727 728static int let_void_SIZE(void *p, struct NewGC *gc) { 729#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 730 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); 731#else 732 return 0; 733#endif 734} 735 736static int let_void_MARK(void *p, struct NewGC *gc) { 737#ifndef GC_NO_MARK_PROCEDURE_NEEDED 738 Scheme_Let_Void *l = (Scheme_Let_Void *)p; 739 740 gcMARK2(l->body, gc); 741 742# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 743 return 0; 744# else 745 return 746 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); 747# endif 748#endif 749} 750 751static int let_void_FIXUP(void *p, struct NewGC *gc) { 752#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 753 Scheme_Let_Void *l = (Scheme_Let_Void *)p; 754 755 gcFIXUP2(l->body, gc); 756 757# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 758 return 0; 759# else 760 return 761 gcBYTES_TO_WORDS(sizeof(Scheme_Let_Void)); 762# endif 763#endif 764} 765 766#define let_void_IS_ATOMIC 0 767#define let_void_IS_CONST_SIZE 1 768 769 770static int letrec_SIZE(void *p, struct NewGC *gc) { 771#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 772 gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); 773#else 774 return 0; 775#endif 776} 777 778static int letrec_MARK(void *p, struct NewGC *gc) { 779#ifndef GC_NO_MARK_PROCEDURE_NEEDED 780 Scheme_Letrec *l = (Scheme_Letrec *)p; 781 782 gcMARK2(l->procs, gc); 783 gcMARK2(l->body, gc); 784 785# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 786 return 0; 787# else 788 return 789 gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); 790# endif 791#endif 792} 793 794static int letrec_FIXUP(void *p, struct NewGC *gc) { 795#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 796 Scheme_Letrec *l = (Scheme_Letrec *)p; 797 798 gcFIXUP2(l->procs, gc); 799 gcFIXUP2(l->body, gc); 800 801# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 802 return 0; 803# else 804 return 805 gcBYTES_TO_WORDS(sizeof(Scheme_Letrec)); 806# endif 807#endif 808} 809 810#define letrec_IS_ATOMIC 0 811#define letrec_IS_CONST_SIZE 1 812 813 814static int let_one_SIZE(void *p, struct NewGC *gc) { 815#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 816 gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); 817#else 818 return 0; 819#endif 820} 821 822static int let_one_MARK(void *p, struct NewGC *gc) { 823#ifndef GC_NO_MARK_PROCEDURE_NEEDED 824 Scheme_Let_One *l = (Scheme_Let_One *)p; 825 826 gcMARK2(l->value, gc); 827 gcMARK2(l->body, gc); 828 829# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 830 return 0; 831# else 832 return 833 gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); 834# endif 835#endif 836} 837 838static int let_one_FIXUP(void *p, struct NewGC *gc) { 839#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 840 Scheme_Let_One *l = (Scheme_Let_One *)p; 841 842 gcFIXUP2(l->value, gc); 843 gcFIXUP2(l->body, gc); 844 845# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 846 return 0; 847# else 848 return 849 gcBYTES_TO_WORDS(sizeof(Scheme_Let_One)); 850# endif 851#endif 852} 853 854#define let_one_IS_ATOMIC 0 855#define let_one_IS_CONST_SIZE 1 856 857 858static int with_cont_mark_SIZE(void *p, struct NewGC *gc) { 859#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 860 gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); 861#else 862 return 0; 863#endif 864} 865 866static int with_cont_mark_MARK(void *p, struct NewGC *gc) { 867#ifndef GC_NO_MARK_PROCEDURE_NEEDED 868 Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p; 869 870 gcMARK2(w->key, gc); 871 gcMARK2(w->val, gc); 872 gcMARK2(w->body, gc); 873 874# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 875 return 0; 876# else 877 return 878 gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); 879# endif 880#endif 881} 882 883static int with_cont_mark_FIXUP(void *p, struct NewGC *gc) { 884#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 885 Scheme_With_Continuation_Mark *w = (Scheme_With_Continuation_Mark *)p; 886 887 gcFIXUP2(w->key, gc); 888 gcFIXUP2(w->val, gc); 889 gcFIXUP2(w->body, gc); 890 891# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 892 return 0; 893# else 894 return 895 gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); 896# endif 897#endif 898} 899 900#define with_cont_mark_IS_ATOMIC 0 901#define with_cont_mark_IS_CONST_SIZE 1 902 903 904static int ir_local_SIZE(void *p, struct NewGC *gc) { 905#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 906 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); 907#else 908 return 0; 909#endif 910} 911 912static int ir_local_MARK(void *p, struct NewGC *gc) { 913#ifndef GC_NO_MARK_PROCEDURE_NEEDED 914 Scheme_IR_Local *var = (Scheme_IR_Local *)p; 915 916 gcMARK2(var->name, gc); 917 switch (var->mode) { 918 case SCHEME_VAR_MODE_COMPILE: 919 gcMARK2(var->compile.use_box, gc); 920 break; 921 case SCHEME_VAR_MODE_LETREC_CHECK: 922 gcMARK2(var->letrec_check.frame, gc); 923 break; 924 case SCHEME_VAR_MODE_OPTIMIZE: 925 gcMARK2(var->optimize.known_val, gc); 926 gcMARK2(var->optimize.transitive_uses, gc); 927 break; 928 case SCHEME_VAR_MODE_RESOLVE: 929 gcMARK2(var->resolve.lifted, gc); 930 break; 931 default: 932 break; 933 } 934 935# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 936 return 0; 937# else 938 return 939 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); 940# endif 941#endif 942} 943 944static int ir_local_FIXUP(void *p, struct NewGC *gc) { 945#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 946 Scheme_IR_Local *var = (Scheme_IR_Local *)p; 947 948 gcFIXUP2(var->name, gc); 949 switch (var->mode) { 950 case SCHEME_VAR_MODE_COMPILE: 951 gcFIXUP2(var->compile.use_box, gc); 952 break; 953 case SCHEME_VAR_MODE_LETREC_CHECK: 954 gcFIXUP2(var->letrec_check.frame, gc); 955 break; 956 case SCHEME_VAR_MODE_OPTIMIZE: 957 gcFIXUP2(var->optimize.known_val, gc); 958 gcFIXUP2(var->optimize.transitive_uses, gc); 959 break; 960 case SCHEME_VAR_MODE_RESOLVE: 961 gcFIXUP2(var->resolve.lifted, gc); 962 break; 963 default: 964 break; 965 } 966 967# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 968 return 0; 969# else 970 return 971 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); 972# endif 973#endif 974} 975 976#define ir_local_IS_ATOMIC 0 977#define ir_local_IS_CONST_SIZE 1 978 979 980static int ir_toplevel_SIZE(void *p, struct NewGC *gc) { 981#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 982 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Toplevel)); 983#else 984 return 0; 985#endif 986} 987 988static int ir_toplevel_MARK(void *p, struct NewGC *gc) { 989#ifndef GC_NO_MARK_PROCEDURE_NEEDED 990# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 991 return 0; 992# else 993 return 994 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Toplevel)); 995# endif 996#endif 997} 998 999static int ir_toplevel_FIXUP(void *p, struct NewGC *gc) { 1000#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1001# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1002 return 0; 1003# else 1004 return 1005 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Toplevel)); 1006# endif 1007#endif 1008} 1009 1010#define ir_toplevel_IS_ATOMIC 1 1011#define ir_toplevel_IS_CONST_SIZE 1 1012 1013 1014static int ir_let_value_SIZE(void *p, struct NewGC *gc) { 1015#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1016 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); 1017#else 1018 return 0; 1019#endif 1020} 1021 1022static int ir_let_value_MARK(void *p, struct NewGC *gc) { 1023#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1024 Scheme_IR_Let_Value *c = (Scheme_IR_Let_Value *)p; 1025 1026 gcMARK2(c->value, gc); 1027 gcMARK2(c->body, gc); 1028 gcMARK2(c->vars, gc); 1029 1030# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1031 return 0; 1032# else 1033 return 1034 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); 1035# endif 1036#endif 1037} 1038 1039static int ir_let_value_FIXUP(void *p, struct NewGC *gc) { 1040#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1041 Scheme_IR_Let_Value *c = (Scheme_IR_Let_Value *)p; 1042 1043 gcFIXUP2(c->value, gc); 1044 gcFIXUP2(c->body, gc); 1045 gcFIXUP2(c->vars, gc); 1046 1047# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1048 return 0; 1049# else 1050 return 1051 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); 1052# endif 1053#endif 1054} 1055 1056#define ir_let_value_IS_ATOMIC 0 1057#define ir_let_value_IS_CONST_SIZE 1 1058 1059 1060static int let_header_SIZE(void *p, struct NewGC *gc) { 1061#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1062 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); 1063#else 1064 return 0; 1065#endif 1066} 1067 1068static int let_header_MARK(void *p, struct NewGC *gc) { 1069#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1070 Scheme_IR_Let_Header *h = (Scheme_IR_Let_Header *)p; 1071 1072 gcMARK2(h->body, gc); 1073 1074# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1075 return 0; 1076# else 1077 return 1078 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); 1079# endif 1080#endif 1081} 1082 1083static int let_header_FIXUP(void *p, struct NewGC *gc) { 1084#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1085 Scheme_IR_Let_Header *h = (Scheme_IR_Let_Header *)p; 1086 1087 gcFIXUP2(h->body, gc); 1088 1089# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1090 return 0; 1091# else 1092 return 1093 gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); 1094# endif 1095#endif 1096} 1097 1098#define let_header_IS_ATOMIC 0 1099#define let_header_IS_CONST_SIZE 1 1100 1101 1102static int set_bang_SIZE(void *p, struct NewGC *gc) { 1103#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1104 gcBYTES_TO_WORDS(sizeof(Scheme_Set_Bang)); 1105#else 1106 return 0; 1107#endif 1108} 1109 1110static int set_bang_MARK(void *p, struct NewGC *gc) { 1111#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1112 Scheme_Set_Bang *b = (Scheme_Set_Bang *)p; 1113 1114 gcMARK2(b->var, gc); 1115 gcMARK2(b->val, gc); 1116 1117# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1118 return 0; 1119# else 1120 return 1121 gcBYTES_TO_WORDS(sizeof(Scheme_Set_Bang)); 1122# endif 1123#endif 1124} 1125 1126static int set_bang_FIXUP(void *p, struct NewGC *gc) { 1127#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1128 Scheme_Set_Bang *b = (Scheme_Set_Bang *)p; 1129 1130 gcFIXUP2(b->var, gc); 1131 gcFIXUP2(b->val, gc); 1132 1133# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1134 return 0; 1135# else 1136 return 1137 gcBYTES_TO_WORDS(sizeof(Scheme_Set_Bang)); 1138# endif 1139#endif 1140} 1141 1142#define set_bang_IS_ATOMIC 0 1143#define set_bang_IS_CONST_SIZE 1 1144 1145 1146static int prim_proc_SIZE(void *p, struct NewGC *gc) { 1147#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1148 Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; 1149 1150 ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) 1151 ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure)) 1152 + ((Scheme_Primitive_Closure *)prim)->count - mzFLEX_DELTA) 1153 : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 1154 ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity)) 1155 : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc)))); 1156#else 1157 return 0; 1158#endif 1159} 1160 1161static int prim_proc_MARK(void *p, struct NewGC *gc) { 1162#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1163 Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; 1164 1165 gcMARK2(prim->name, gc); 1166 if (prim->mina < 0) { 1167 gcMARK2(prim->mu.cases, gc); 1168 } 1169 if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) { 1170 Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim; 1171 int i; 1172 for (i = cc->count; i--; ) { 1173 gcMARK2(cc->val[i], gc); 1174 } 1175 } 1176 1177# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1178 return 0; 1179# else 1180 return 1181 ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) 1182 ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure)) 1183 + ((Scheme_Primitive_Closure *)prim)->count - mzFLEX_DELTA) 1184 : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 1185 ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity)) 1186 : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc)))); 1187# endif 1188#endif 1189} 1190 1191static int prim_proc_FIXUP(void *p, struct NewGC *gc) { 1192#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1193 Scheme_Primitive_Proc *prim = (Scheme_Primitive_Proc *)p; 1194 1195 gcFIXUP2(prim->name, gc); 1196 if (prim->mina < 0) { 1197 gcFIXUP2(prim->mu.cases, gc); 1198 } 1199 if (prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) { 1200 Scheme_Primitive_Closure *cc = (Scheme_Primitive_Closure *)prim; 1201 int i; 1202 for (i = cc->count; i--; ) { 1203 gcFIXUP2(cc->val[i], gc); 1204 } 1205 } 1206 1207# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1208 return 0; 1209# else 1210 return 1211 ((prim->pp.flags & SCHEME_PRIM_IS_CLOSURE) 1212 ? (gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Closure)) 1213 + ((Scheme_Primitive_Closure *)prim)->count - mzFLEX_DELTA) 1214 : ((prim->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 1215 ? gcBYTES_TO_WORDS(sizeof(Scheme_Prim_W_Result_Arity)) 1216 : gcBYTES_TO_WORDS(sizeof(Scheme_Primitive_Proc)))); 1217# endif 1218#endif 1219} 1220 1221#define prim_proc_IS_ATOMIC 0 1222#define prim_proc_IS_CONST_SIZE 0 1223 1224 1225static int closed_prim_proc_SIZE(void *p, struct NewGC *gc) { 1226#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1227 Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; 1228 1229 ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 1230 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity)) 1231 : ((c->mina == -2) 1232 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc)) 1233 : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc)))); 1234#else 1235 return 0; 1236#endif 1237} 1238 1239static int closed_prim_proc_MARK(void *p, struct NewGC *gc) { 1240#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1241 Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; 1242 1243 gcMARK2(c->name, gc); 1244 gcMARK2(SCHEME_CLSD_PRIM_DATA(c), gc); 1245 if (c->mina == -2) { 1246 gcMARK2(((Scheme_Closed_Case_Primitive_Proc *)c)->cases, gc); 1247 } 1248 1249# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1250 return 0; 1251# else 1252 return 1253 ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 1254 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity)) 1255 : ((c->mina == -2) 1256 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc)) 1257 : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc)))); 1258# endif 1259#endif 1260} 1261 1262static int closed_prim_proc_FIXUP(void *p, struct NewGC *gc) { 1263#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1264 Scheme_Closed_Primitive_Proc *c = (Scheme_Closed_Primitive_Proc *)p; 1265 1266 gcFIXUP2(c->name, gc); 1267 gcFIXUP2(SCHEME_CLSD_PRIM_DATA(c), gc); 1268 if (c->mina == -2) { 1269 gcFIXUP2(((Scheme_Closed_Case_Primitive_Proc *)c)->cases, gc); 1270 } 1271 1272# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1273 return 0; 1274# else 1275 return 1276 ((c->pp.flags & SCHEME_PRIM_IS_MULTI_RESULT) 1277 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Prim_W_Result_Arity)) 1278 : ((c->mina == -2) 1279 ? gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Case_Primitive_Proc)) 1280 : gcBYTES_TO_WORDS(sizeof(Scheme_Closed_Primitive_Proc)))); 1281# endif 1282#endif 1283} 1284 1285#define closed_prim_proc_IS_ATOMIC 0 1286#define closed_prim_proc_IS_CONST_SIZE 0 1287 1288 1289static int scm_closure_SIZE(void *p, struct NewGC *gc) { 1290#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1291 Scheme_Closure *c = (Scheme_Closure *)p; 1292 int closure_size = (c->code 1293 ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size 1294 : 0); 1295 1296 gcBYTES_TO_WORDS((sizeof(Scheme_Closure) 1297 + (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); 1298#else 1299 return 0; 1300#endif 1301} 1302 1303static int scm_closure_MARK(void *p, struct NewGC *gc) { 1304#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1305 Scheme_Closure *c = (Scheme_Closure *)p; 1306 int closure_size = (c->code 1307 ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size 1308 : 0); 1309 1310 1311 int i = closure_size; 1312# define CLOSURE_DATA_TYPE Scheme_Lambda 1313# include "mzclpf_decl.inc" 1314 1315 gcMARK2(c->code, gc); 1316 1317# include "mzclpf_pre.inc" 1318 1319 while (i--) 1320 gcMARK2(c->vals[i], gc); 1321 1322# include "mzclpf_post.inc" 1323# undef CLOSURE_DATA_TYPE 1324 1325# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1326 return 0; 1327# else 1328 return 1329 gcBYTES_TO_WORDS((sizeof(Scheme_Closure) 1330 + (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); 1331# endif 1332#endif 1333} 1334 1335static int scm_closure_FIXUP(void *p, struct NewGC *gc) { 1336#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1337 Scheme_Closure *c = (Scheme_Closure *)p; 1338 int closure_size = (c->code 1339 ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size 1340 : 0); 1341 1342 1343 int i = closure_size; 1344 1345 gcFIXUP2(c->code, gc); 1346 1347 1348 while (i--) 1349 gcFIXUP2(c->vals[i], gc); 1350 1351 1352# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1353 return 0; 1354# else 1355 return 1356 gcBYTES_TO_WORDS((sizeof(Scheme_Closure) 1357 + (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); 1358# endif 1359#endif 1360} 1361 1362#define scm_closure_IS_ATOMIC 0 1363#define scm_closure_IS_CONST_SIZE 0 1364 1365 1366static int case_closure_SIZE(void *p, struct NewGC *gc) { 1367#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1368 Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; 1369 1370 gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda) 1371 + ((c->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 1372#else 1373 return 0; 1374#endif 1375} 1376 1377static int case_closure_MARK(void *p, struct NewGC *gc) { 1378#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1379 Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; 1380 1381 int i; 1382 1383 for (i = c->count; i--; ) 1384 gcMARK2(c->array[i], gc); 1385 gcMARK2(c->name, gc); 1386#ifdef MZ_USE_JIT 1387 gcMARK2(c->native_code, gc); 1388#endif 1389 1390# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1391 return 0; 1392# else 1393 return 1394 gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda) 1395 + ((c->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 1396# endif 1397#endif 1398} 1399 1400static int case_closure_FIXUP(void *p, struct NewGC *gc) { 1401#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1402 Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)p; 1403 1404 int i; 1405 1406 for (i = c->count; i--; ) 1407 gcFIXUP2(c->array[i], gc); 1408 gcFIXUP2(c->name, gc); 1409#ifdef MZ_USE_JIT 1410 gcFIXUP2(c->native_code, gc); 1411#endif 1412 1413# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1414 return 0; 1415# else 1416 return 1417 gcBYTES_TO_WORDS((sizeof(Scheme_Case_Lambda) 1418 + ((c->count - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 1419# endif 1420#endif 1421} 1422 1423#define case_closure_IS_ATOMIC 0 1424#define case_closure_IS_CONST_SIZE 0 1425 1426 1427static int cont_proc_SIZE(void *p, struct NewGC *gc) { 1428#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1429 gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); 1430#else 1431 return 0; 1432#endif 1433} 1434 1435static int cont_proc_MARK(void *p, struct NewGC *gc) { 1436#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1437 Scheme_Cont *c = (Scheme_Cont *)p; 1438 1439 gcMARK2(c->dw, gc); 1440 gcMARK2(c->prompt_tag, gc); 1441 gcMARK2(c->meta_continuation, gc); 1442 gcMARK2(c->meta_continuation_src, gc); 1443 gcMARK2(c->common_dw, gc); 1444 gcMARK2(c->save_overflow, gc); 1445 gcMARK2(c->runstack_copied, gc); 1446 gcMARK2(c->runstack_owner, gc); 1447 gcMARK2(c->cont_mark_stack_copied, gc); 1448 gcMARK2(c->cont_mark_stack_owner, gc); 1449 gcMARK2(c->init_config, gc); 1450 gcMARK2(c->init_break_cell, gc); 1451#ifdef MZ_USE_JIT 1452 gcMARK2(c->native_trace, gc); 1453#endif 1454 1455 gcMARK2(c->buf_ptr, gc); 1456 MARK_cjs(&c->cjs, gc); 1457 MARK_stack_state(&c->ss, gc); 1458 gcMARK2(c->barrier_prompt, gc); 1459 if (!GC_merely_accounting()) { 1460 gcMARK2(c->runstack_start, gc); 1461 gcMARK2(c->runstack_saved, gc); 1462 } 1463 1464 gcMARK2(c->prompt_id, gc); 1465 gcMARK2(c->prompt_buf, gc); 1466 1467 gcMARK2(c->escape_cont, gc); 1468 1469 gcMARK2(c->value, gc); 1470 gcMARK2(c->resume_to, gc); 1471 gcMARK2(c->use_next_cont, gc); 1472 gcMARK2(c->extra_marks, gc); 1473 gcMARK2(c->shortcut_prompt, gc); 1474 1475# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1476 return 0; 1477# else 1478 return 1479 gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); 1480# endif 1481#endif 1482} 1483 1484static int cont_proc_FIXUP(void *p, struct NewGC *gc) { 1485#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1486 Scheme_Cont *c = (Scheme_Cont *)p; 1487 1488 gcFIXUP2(c->dw, gc); 1489 gcFIXUP2(c->prompt_tag, gc); 1490 gcFIXUP2(c->meta_continuation, gc); 1491 gcFIXUP2(c->meta_continuation_src, gc); 1492 gcFIXUP2(c->common_dw, gc); 1493 gcFIXUP2(c->save_overflow, gc); 1494 gcFIXUP2(c->runstack_copied, gc); 1495 gcFIXUP2(c->runstack_owner, gc); 1496 gcFIXUP2(c->cont_mark_stack_copied, gc); 1497 gcFIXUP2(c->cont_mark_stack_owner, gc); 1498 gcFIXUP2(c->init_config, gc); 1499 gcFIXUP2(c->init_break_cell, gc); 1500#ifdef MZ_USE_JIT 1501 gcFIXUP2(c->native_trace, gc); 1502#endif 1503 1504 gcFIXUP2(c->buf_ptr, gc); 1505 FIXUP_cjs(&c->cjs, gc); 1506 FIXUP_stack_state(&c->ss, gc); 1507 gcFIXUP2(c->barrier_prompt, gc); 1508 if (!GC_merely_accounting()) { 1509 gcFIXUP2(c->runstack_start, gc); 1510 gcFIXUP2(c->runstack_saved, gc); 1511 } 1512 1513 gcFIXUP2(c->prompt_id, gc); 1514 gcFIXUP2(c->prompt_buf, gc); 1515 1516 gcFIXUP2(c->escape_cont, gc); 1517 1518 gcFIXUP2(c->value, gc); 1519 gcFIXUP2(c->resume_to, gc); 1520 gcFIXUP2(c->use_next_cont, gc); 1521 gcFIXUP2(c->extra_marks, gc); 1522 gcFIXUP2(c->shortcut_prompt, gc); 1523 1524# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1525 return 0; 1526# else 1527 return 1528 gcBYTES_TO_WORDS(sizeof(Scheme_Cont)); 1529# endif 1530#endif 1531} 1532 1533#define cont_proc_IS_ATOMIC 0 1534#define cont_proc_IS_CONST_SIZE 1 1535 1536 1537static int cont_jmp_proc_SIZE(void *p, struct NewGC *gc) { 1538#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1539 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Jmp)); 1540#else 1541 return 0; 1542#endif 1543} 1544 1545static int cont_jmp_proc_MARK(void *p, struct NewGC *gc) { 1546#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1547 Scheme_Cont_Jmp *c = (Scheme_Cont_Jmp *)p; 1548 1549 MARK_jmpup(&c->buf, gc); 1550 1551# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1552 return 0; 1553# else 1554 return 1555 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Jmp)); 1556# endif 1557#endif 1558} 1559 1560static int cont_jmp_proc_FIXUP(void *p, struct NewGC *gc) { 1561#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1562 Scheme_Cont_Jmp *c = (Scheme_Cont_Jmp *)p; 1563 1564 FIXUP_jmpup(&c->buf, gc); 1565 1566# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1567 return 0; 1568# else 1569 return 1570 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Jmp)); 1571# endif 1572#endif 1573} 1574 1575#define cont_jmp_proc_IS_ATOMIC 0 1576#define cont_jmp_proc_IS_CONST_SIZE 1 1577 1578 1579static int meta_cont_proc_SIZE(void *p, struct NewGC *gc) { 1580#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1581 gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); 1582#else 1583 return 0; 1584#endif 1585} 1586 1587static int meta_cont_proc_MARK(void *p, struct NewGC *gc) { 1588#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1589 Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p; 1590 1591 gcMARK2(c->prompt_tag, gc); 1592 gcMARK2(c->overflow, gc); 1593 gcMARK2(c->next, gc); 1594 gcMARK2(c->cont_mark_stack_copied, gc); 1595 gcMARK2(c->cont, gc); 1596 1597# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1598 return 0; 1599# else 1600 return 1601 gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); 1602# endif 1603#endif 1604} 1605 1606static int meta_cont_proc_FIXUP(void *p, struct NewGC *gc) { 1607#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1608 Scheme_Meta_Continuation *c = (Scheme_Meta_Continuation *)p; 1609 1610 gcFIXUP2(c->prompt_tag, gc); 1611 gcFIXUP2(c->overflow, gc); 1612 gcFIXUP2(c->next, gc); 1613 gcFIXUP2(c->cont_mark_stack_copied, gc); 1614 gcFIXUP2(c->cont, gc); 1615 1616# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1617 return 0; 1618# else 1619 return 1620 gcBYTES_TO_WORDS(sizeof(Scheme_Meta_Continuation)); 1621# endif 1622#endif 1623} 1624 1625#define meta_cont_proc_IS_ATOMIC 0 1626#define meta_cont_proc_IS_CONST_SIZE 1 1627 1628 1629static int mark_dyn_wind_SIZE(void *p, struct NewGC *gc) { 1630#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1631 gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); 1632#else 1633 return 0; 1634#endif 1635} 1636 1637static int mark_dyn_wind_MARK(void *p, struct NewGC *gc) { 1638#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1639 Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p; 1640 1641 gcMARK2(dw->id, gc); 1642 gcMARK2(dw->data, gc); 1643 gcMARK2(dw->prompt_tag, gc); 1644 gcMARK2(dw->prev, gc); 1645 1646 MARK_stack_state(&dw->envss, gc); 1647 1648# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1649 return 0; 1650# else 1651 return 1652 gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); 1653# endif 1654#endif 1655} 1656 1657static int mark_dyn_wind_FIXUP(void *p, struct NewGC *gc) { 1658#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1659 Scheme_Dynamic_Wind *dw = (Scheme_Dynamic_Wind *)p; 1660 1661 gcFIXUP2(dw->id, gc); 1662 gcFIXUP2(dw->data, gc); 1663 gcFIXUP2(dw->prompt_tag, gc); 1664 gcFIXUP2(dw->prev, gc); 1665 1666 FIXUP_stack_state(&dw->envss, gc); 1667 1668# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1669 return 0; 1670# else 1671 return 1672 gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind)); 1673# endif 1674#endif 1675} 1676 1677#define mark_dyn_wind_IS_ATOMIC 0 1678#define mark_dyn_wind_IS_CONST_SIZE 1 1679 1680 1681static int mark_overflow_SIZE(void *p, struct NewGC *gc) { 1682#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1683 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); 1684#else 1685 return 0; 1686#endif 1687} 1688 1689static int mark_overflow_MARK(void *p, struct NewGC *gc) { 1690#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1691 Scheme_Overflow *o = (Scheme_Overflow *)p; 1692 1693 gcMARK2(o->prev, gc); 1694 gcMARK2(o->jmp, gc); 1695 gcMARK2(o->id, gc); 1696 1697# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1698 return 0; 1699# else 1700 return 1701 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); 1702# endif 1703#endif 1704} 1705 1706static int mark_overflow_FIXUP(void *p, struct NewGC *gc) { 1707#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1708 Scheme_Overflow *o = (Scheme_Overflow *)p; 1709 1710 gcFIXUP2(o->prev, gc); 1711 gcFIXUP2(o->jmp, gc); 1712 gcFIXUP2(o->id, gc); 1713 1714# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1715 return 0; 1716# else 1717 return 1718 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow)); 1719# endif 1720#endif 1721} 1722 1723#define mark_overflow_IS_ATOMIC 0 1724#define mark_overflow_IS_CONST_SIZE 1 1725 1726 1727static int mark_overflow_jmp_SIZE(void *p, struct NewGC *gc) { 1728#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1729 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); 1730#else 1731 return 0; 1732#endif 1733} 1734 1735static int mark_overflow_jmp_MARK(void *p, struct NewGC *gc) { 1736#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1737 Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p; 1738 1739 MARK_jmpup(&o->cont, gc); 1740 1741# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1742 return 0; 1743# else 1744 return 1745 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); 1746# endif 1747#endif 1748} 1749 1750static int mark_overflow_jmp_FIXUP(void *p, struct NewGC *gc) { 1751#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1752 Scheme_Overflow_Jmp *o = (Scheme_Overflow_Jmp *)p; 1753 1754 FIXUP_jmpup(&o->cont, gc); 1755 1756# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1757 return 0; 1758# else 1759 return 1760 gcBYTES_TO_WORDS(sizeof(Scheme_Overflow_Jmp)); 1761# endif 1762#endif 1763} 1764 1765#define mark_overflow_jmp_IS_ATOMIC 0 1766#define mark_overflow_jmp_IS_CONST_SIZE 1 1767 1768 1769static int escaping_cont_proc_SIZE(void *p, struct NewGC *gc) { 1770#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1771 gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); 1772#else 1773 return 0; 1774#endif 1775} 1776 1777static int escaping_cont_proc_MARK(void *p, struct NewGC *gc) { 1778#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1779 Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p; 1780 1781#ifdef MZ_USE_JIT 1782 gcMARK2(c->native_trace, gc); 1783#endif 1784 1785 gcMARK2(c->barrier_prompt, gc); 1786 MARK_stack_state(&c->envss, gc); 1787 1788# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1789 return 0; 1790# else 1791 return 1792 gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); 1793# endif 1794#endif 1795} 1796 1797static int escaping_cont_proc_FIXUP(void *p, struct NewGC *gc) { 1798#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1799 Scheme_Escaping_Cont *c = (Scheme_Escaping_Cont *)p; 1800 1801#ifdef MZ_USE_JIT 1802 gcFIXUP2(c->native_trace, gc); 1803#endif 1804 1805 gcFIXUP2(c->barrier_prompt, gc); 1806 FIXUP_stack_state(&c->envss, gc); 1807 1808# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1809 return 0; 1810# else 1811 return 1812 gcBYTES_TO_WORDS(sizeof(Scheme_Escaping_Cont)); 1813# endif 1814#endif 1815} 1816 1817#define escaping_cont_proc_IS_ATOMIC 0 1818#define escaping_cont_proc_IS_CONST_SIZE 1 1819 1820 1821static int bignum_obj_SIZE(void *p, struct NewGC *gc) { 1822#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1823 Scheme_Bignum *b = (Scheme_Bignum *)p; 1824 1825 ((!SCHEME_BIGINLINE(b)) 1826 ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum)) 1827 : gcBYTES_TO_WORDS(sizeof(Small_Bignum))); 1828#else 1829 return 0; 1830#endif 1831} 1832 1833static int bignum_obj_MARK(void *p, struct NewGC *gc) { 1834#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1835 Scheme_Bignum *b = (Scheme_Bignum *)p; 1836 1837 if (!SCHEME_BIGINLINE(b)) { 1838 gcMARK2(b->digits, gc); 1839 } else { 1840 b->digits = ((Small_Bignum *)GC_fixup_self(b))->v; 1841 } 1842 1843# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1844 return 0; 1845# else 1846 return 1847 ((!SCHEME_BIGINLINE(b)) 1848 ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum)) 1849 : gcBYTES_TO_WORDS(sizeof(Small_Bignum))); 1850# endif 1851#endif 1852} 1853 1854static int bignum_obj_FIXUP(void *p, struct NewGC *gc) { 1855#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1856 Scheme_Bignum *b = (Scheme_Bignum *)p; 1857 1858 if (!SCHEME_BIGINLINE(b)) { 1859 gcFIXUP2(b->digits, gc); 1860 } else { 1861 b->digits = ((Small_Bignum *)GC_fixup_self(b))->v; 1862 } 1863 1864# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1865 return 0; 1866# else 1867 return 1868 ((!SCHEME_BIGINLINE(b)) 1869 ? gcBYTES_TO_WORDS(sizeof(Scheme_Bignum)) 1870 : gcBYTES_TO_WORDS(sizeof(Small_Bignum))); 1871# endif 1872#endif 1873} 1874 1875#define bignum_obj_IS_ATOMIC 0 1876#define bignum_obj_IS_CONST_SIZE 0 1877 1878 1879static int rational_obj_SIZE(void *p, struct NewGC *gc) { 1880#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1881 gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); 1882#else 1883 return 0; 1884#endif 1885} 1886 1887static int rational_obj_MARK(void *p, struct NewGC *gc) { 1888#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1889 Scheme_Rational *r = (Scheme_Rational *)p; 1890 1891 gcMARK2(r->num, gc); 1892 gcMARK2(r->denom, gc); 1893 1894# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1895 return 0; 1896# else 1897 return 1898 gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); 1899# endif 1900#endif 1901} 1902 1903static int rational_obj_FIXUP(void *p, struct NewGC *gc) { 1904#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1905 Scheme_Rational *r = (Scheme_Rational *)p; 1906 1907 gcFIXUP2(r->num, gc); 1908 gcFIXUP2(r->denom, gc); 1909 1910# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1911 return 0; 1912# else 1913 return 1914 gcBYTES_TO_WORDS(sizeof(Scheme_Rational)); 1915# endif 1916#endif 1917} 1918 1919#define rational_obj_IS_ATOMIC 0 1920#define rational_obj_IS_CONST_SIZE 1 1921 1922 1923static int float_obj_SIZE(void *p, struct NewGC *gc) { 1924#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1925#ifdef MZ_USE_SINGLE_FLOATS 1926 gcBYTES_TO_WORDS(sizeof(Scheme_Float)); 1927#else 1928 0; 1929#endif 1930#else 1931 return 0; 1932#endif 1933} 1934 1935static int float_obj_MARK(void *p, struct NewGC *gc) { 1936#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1937# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1938 return 0; 1939# else 1940 return 1941#ifdef MZ_USE_SINGLE_FLOATS 1942 gcBYTES_TO_WORDS(sizeof(Scheme_Float)); 1943#else 1944 0; 1945#endif 1946# endif 1947#endif 1948} 1949 1950static int float_obj_FIXUP(void *p, struct NewGC *gc) { 1951#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1952# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1953 return 0; 1954# else 1955 return 1956#ifdef MZ_USE_SINGLE_FLOATS 1957 gcBYTES_TO_WORDS(sizeof(Scheme_Float)); 1958#else 1959 0; 1960#endif 1961# endif 1962#endif 1963} 1964 1965#define float_obj_IS_ATOMIC 1 1966#define float_obj_IS_CONST_SIZE 0 1967 1968 1969static int double_obj_SIZE(void *p, struct NewGC *gc) { 1970#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 1971 gcBYTES_TO_WORDS(sizeof(Scheme_Double)); 1972#else 1973 return 0; 1974#endif 1975} 1976 1977static int double_obj_MARK(void *p, struct NewGC *gc) { 1978#ifndef GC_NO_MARK_PROCEDURE_NEEDED 1979# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1980 return 0; 1981# else 1982 return 1983 gcBYTES_TO_WORDS(sizeof(Scheme_Double)); 1984# endif 1985#endif 1986} 1987 1988static int double_obj_FIXUP(void *p, struct NewGC *gc) { 1989#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 1990# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 1991 return 0; 1992# else 1993 return 1994 gcBYTES_TO_WORDS(sizeof(Scheme_Double)); 1995# endif 1996#endif 1997} 1998 1999#define double_obj_IS_ATOMIC 1 2000#define double_obj_IS_CONST_SIZE 1 2001 2002 2003#ifdef MZ_LONG_DOUBLE 2004static int long_double_obj_SIZE(void *p, struct NewGC *gc) { 2005#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2006 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 2007#else 2008 return 0; 2009#endif 2010} 2011 2012static int long_double_obj_MARK(void *p, struct NewGC *gc) { 2013#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2014# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2015 return 0; 2016# else 2017 return 2018 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 2019# endif 2020#endif 2021} 2022 2023static int long_double_obj_FIXUP(void *p, struct NewGC *gc) { 2024#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2025# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2026 return 0; 2027# else 2028 return 2029 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 2030# endif 2031#endif 2032} 2033 2034#define long_double_obj_IS_ATOMIC 1 2035#define long_double_obj_IS_CONST_SIZE 1 2036 2037#else 2038static int long_double_obj_SIZE(void *p, struct NewGC *gc) { 2039#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2040 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 2041#else 2042 return 0; 2043#endif 2044} 2045 2046static int long_double_obj_MARK(void *p, struct NewGC *gc) { 2047#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2048 Scheme_Long_Double *ld = (Scheme_Long_Double *)p; 2049 gcMARK2(ld->printed_form, gc); 2050# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2051 return 0; 2052# else 2053 return 2054 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 2055# endif 2056#endif 2057} 2058 2059static int long_double_obj_FIXUP(void *p, struct NewGC *gc) { 2060#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2061 Scheme_Long_Double *ld = (Scheme_Long_Double *)p; 2062 gcFIXUP2(ld->printed_form, gc); 2063# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2064 return 0; 2065# else 2066 return 2067 gcBYTES_TO_WORDS(sizeof(Scheme_Long_Double)); 2068# endif 2069#endif 2070} 2071 2072#define long_double_obj_IS_ATOMIC 0 2073#define long_double_obj_IS_CONST_SIZE 1 2074 2075#endif 2076 2077static int complex_obj_SIZE(void *p, struct NewGC *gc) { 2078#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2079 gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); 2080#else 2081 return 0; 2082#endif 2083} 2084 2085static int complex_obj_MARK(void *p, struct NewGC *gc) { 2086#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2087 Scheme_Complex *c = (Scheme_Complex *)p; 2088 2089 gcMARK2(c->r, gc); 2090 gcMARK2(c->i, gc); 2091 2092# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2093 return 0; 2094# else 2095 return 2096 gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); 2097# endif 2098#endif 2099} 2100 2101static int complex_obj_FIXUP(void *p, struct NewGC *gc) { 2102#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2103 Scheme_Complex *c = (Scheme_Complex *)p; 2104 2105 gcFIXUP2(c->r, gc); 2106 gcFIXUP2(c->i, gc); 2107 2108# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2109 return 0; 2110# else 2111 return 2112 gcBYTES_TO_WORDS(sizeof(Scheme_Complex)); 2113# endif 2114#endif 2115} 2116 2117#define complex_obj_IS_ATOMIC 0 2118#define complex_obj_IS_CONST_SIZE 1 2119 2120 2121static int string_obj_SIZE(void *p, struct NewGC *gc) { 2122#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2123 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2124#else 2125 return 0; 2126#endif 2127} 2128 2129static int string_obj_MARK(void *p, struct NewGC *gc) { 2130#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2131 Scheme_Object *o = (Scheme_Object *)p; 2132 gcMARK2(SCHEME_CHAR_STR_VAL(o), gc); 2133 2134# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2135 return 0; 2136# else 2137 return 2138 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2139# endif 2140#endif 2141} 2142 2143static int string_obj_FIXUP(void *p, struct NewGC *gc) { 2144#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2145 Scheme_Object *o = (Scheme_Object *)p; 2146 gcFIXUP2(SCHEME_CHAR_STR_VAL(o), gc); 2147 2148# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2149 return 0; 2150# else 2151 return 2152 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2153# endif 2154#endif 2155} 2156 2157#define string_obj_IS_ATOMIC 0 2158#define string_obj_IS_CONST_SIZE 1 2159 2160 2161static int bstring_obj_SIZE(void *p, struct NewGC *gc) { 2162#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2163 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2164#else 2165 return 0; 2166#endif 2167} 2168 2169static int bstring_obj_MARK(void *p, struct NewGC *gc) { 2170#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2171 Scheme_Object *o = (Scheme_Object *)p; 2172 gcMARK2(SCHEME_BYTE_STR_VAL(o), gc); 2173 2174# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2175 return 0; 2176# else 2177 return 2178 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2179# endif 2180#endif 2181} 2182 2183static int bstring_obj_FIXUP(void *p, struct NewGC *gc) { 2184#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2185 Scheme_Object *o = (Scheme_Object *)p; 2186 gcFIXUP2(SCHEME_BYTE_STR_VAL(o), gc); 2187 2188# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2189 return 0; 2190# else 2191 return 2192 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2193# endif 2194#endif 2195} 2196 2197#define bstring_obj_IS_ATOMIC 0 2198#define bstring_obj_IS_CONST_SIZE 1 2199 2200 2201static int symbol_obj_SIZE(void *p, struct NewGC *gc) { 2202#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2203 gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + ((Scheme_Symbol *)p)->len + 1 - mzFLEX4_DELTA); 2204#else 2205 return 0; 2206#endif 2207} 2208 2209static int symbol_obj_MARK(void *p, struct NewGC *gc) { 2210#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2211# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2212 return 0; 2213# else 2214 return 2215 gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + ((Scheme_Symbol *)p)->len + 1 - mzFLEX4_DELTA); 2216# endif 2217#endif 2218} 2219 2220static int symbol_obj_FIXUP(void *p, struct NewGC *gc) { 2221#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2222# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2223 return 0; 2224# else 2225 return 2226 gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + ((Scheme_Symbol *)p)->len + 1 - mzFLEX4_DELTA); 2227# endif 2228#endif 2229} 2230 2231#define symbol_obj_IS_ATOMIC 1 2232#define symbol_obj_IS_CONST_SIZE 0 2233 2234 2235static int cons_cell_SIZE(void *p, struct NewGC *gc) { 2236#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2237 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2238#else 2239 return 0; 2240#endif 2241} 2242 2243static int cons_cell_MARK(void *p, struct NewGC *gc) { 2244#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2245 Scheme_Object *o = (Scheme_Object *)p; 2246 2247 gcMARK2(SCHEME_CAR(o), gc); 2248 gcMARK2(SCHEME_CDR(o), gc); 2249 2250# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2251 return 0; 2252# else 2253 return 2254 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2255# endif 2256#endif 2257} 2258 2259static int cons_cell_FIXUP(void *p, struct NewGC *gc) { 2260#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2261 Scheme_Object *o = (Scheme_Object *)p; 2262 2263 gcFIXUP2(SCHEME_CAR(o), gc); 2264 gcFIXUP2(SCHEME_CDR(o), gc); 2265 2266# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2267 return 0; 2268# else 2269 return 2270 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 2271# endif 2272#endif 2273} 2274 2275#define cons_cell_IS_ATOMIC 0 2276#define cons_cell_IS_CONST_SIZE 1 2277 2278 2279static int vector_obj_SIZE(void *p, struct NewGC *gc) { 2280#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2281 Scheme_Vector *vec = (Scheme_Vector *)p; 2282 2283 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 2284 + ((vec->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 2285#else 2286 return 0; 2287#endif 2288} 2289 2290static int vector_obj_MARK(void *p, struct NewGC *gc) { 2291#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2292 Scheme_Vector *vec = (Scheme_Vector *)p; 2293 2294 int i; 2295 for (i = vec->size; i--; ) 2296 gcMARK2(vec->els[i], gc); 2297 2298# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2299 return 0; 2300# else 2301 return 2302 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 2303 + ((vec->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 2304# endif 2305#endif 2306} 2307 2308static int vector_obj_FIXUP(void *p, struct NewGC *gc) { 2309#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2310 Scheme_Vector *vec = (Scheme_Vector *)p; 2311 2312 int i; 2313 for (i = vec->size; i--; ) 2314 gcFIXUP2(vec->els[i], gc); 2315 2316# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2317 return 0; 2318# else 2319 return 2320 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 2321 + ((vec->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 2322# endif 2323#endif 2324} 2325 2326#define vector_obj_IS_ATOMIC 0 2327#define vector_obj_IS_CONST_SIZE 0 2328 2329 2330static int fxvector_obj_SIZE(void *p, struct NewGC *gc) { 2331#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2332 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 2333 + ((((Scheme_Vector *)p)->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 2334#else 2335 return 0; 2336#endif 2337} 2338 2339static int fxvector_obj_MARK(void *p, struct NewGC *gc) { 2340#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2341# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2342 return 0; 2343# else 2344 return 2345 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 2346 + ((((Scheme_Vector *)p)->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 2347# endif 2348#endif 2349} 2350 2351static int fxvector_obj_FIXUP(void *p, struct NewGC *gc) { 2352#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2353# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2354 return 0; 2355# else 2356 return 2357 gcBYTES_TO_WORDS((sizeof(Scheme_Vector) 2358 + ((((Scheme_Vector *)p)->size - mzFLEX_DELTA) * sizeof(Scheme_Object *)))); 2359# endif 2360#endif 2361} 2362 2363#define fxvector_obj_IS_ATOMIC 1 2364#define fxvector_obj_IS_CONST_SIZE 0 2365 2366 2367static int flvector_obj_SIZE(void *p, struct NewGC *gc) { 2368#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2369 gcBYTES_TO_WORDS((sizeof(Scheme_Double_Vector) 2370 + ((((Scheme_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(double)))); 2371#else 2372 return 0; 2373#endif 2374} 2375 2376static int flvector_obj_MARK(void *p, struct NewGC *gc) { 2377#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2378# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2379 return 0; 2380# else 2381 return 2382 gcBYTES_TO_WORDS((sizeof(Scheme_Double_Vector) 2383 + ((((Scheme_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(double)))); 2384# endif 2385#endif 2386} 2387 2388static int flvector_obj_FIXUP(void *p, struct NewGC *gc) { 2389#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2390# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2391 return 0; 2392# else 2393 return 2394 gcBYTES_TO_WORDS((sizeof(Scheme_Double_Vector) 2395 + ((((Scheme_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(double)))); 2396# endif 2397#endif 2398} 2399 2400#define flvector_obj_IS_ATOMIC 1 2401#define flvector_obj_IS_CONST_SIZE 0 2402 2403 2404#ifdef MZ_LONG_DOUBLE 2405static int extflvector_obj_SIZE(void *p, struct NewGC *gc) { 2406#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2407 gcBYTES_TO_WORDS((sizeof(Scheme_Long_Double_Vector) 2408 + ((((Scheme_Long_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(long double)))); 2409#else 2410 return 0; 2411#endif 2412} 2413 2414static int extflvector_obj_MARK(void *p, struct NewGC *gc) { 2415#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2416# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2417 return 0; 2418# else 2419 return 2420 gcBYTES_TO_WORDS((sizeof(Scheme_Long_Double_Vector) 2421 + ((((Scheme_Long_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(long double)))); 2422# endif 2423#endif 2424} 2425 2426static int extflvector_obj_FIXUP(void *p, struct NewGC *gc) { 2427#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2428# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2429 return 0; 2430# else 2431 return 2432 gcBYTES_TO_WORDS((sizeof(Scheme_Long_Double_Vector) 2433 + ((((Scheme_Long_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(long double)))); 2434# endif 2435#endif 2436} 2437 2438#define extflvector_obj_IS_ATOMIC 1 2439#define extflvector_obj_IS_CONST_SIZE 0 2440 2441#endif 2442 2443static int input_port_SIZE(void *p, struct NewGC *gc) { 2444#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2445 gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); 2446#else 2447 return 0; 2448#endif 2449} 2450 2451static int input_port_MARK(void *p, struct NewGC *gc) { 2452#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2453 Scheme_Input_Port *ip = (Scheme_Input_Port *)p; 2454 2455 gcMARK2(ip->p.position_redirect, gc); 2456 gcMARK2(ip->sub_type, gc); 2457 gcMARK2(ip->port_data, gc); 2458 gcMARK2(ip->name, gc); 2459 gcMARK2(ip->peeked_read, gc); 2460 gcMARK2(ip->peeked_write, gc); 2461 gcMARK2(ip->read_handler, gc); 2462 gcMARK2(ip->closed_evt, gc); 2463 gcMARK2(ip->mref, gc); 2464 gcMARK2(ip->output_half, gc); 2465 gcMARK2(ip->special, gc); 2466 gcMARK2(ip->ungotten_special, gc); 2467 gcMARK2(ip->progress_evt, gc); 2468 gcMARK2(ip->input_lock, gc); 2469 gcMARK2(ip->input_giveup, gc); 2470 gcMARK2(ip->input_extras, gc); 2471 gcMARK2(ip->input_extras_ready, gc); 2472 gcMARK2(ip->unless, gc); 2473 gcMARK2(ip->unless_cache, gc); 2474#ifdef WINDOWS_FILE_HANDLES 2475 gcMARK2(ip->bufwidths, gc); 2476#endif 2477 2478# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2479 return 0; 2480# else 2481 return 2482 gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); 2483# endif 2484#endif 2485} 2486 2487static int input_port_FIXUP(void *p, struct NewGC *gc) { 2488#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2489 Scheme_Input_Port *ip = (Scheme_Input_Port *)p; 2490 2491 gcFIXUP2(ip->p.position_redirect, gc); 2492 gcFIXUP2(ip->sub_type, gc); 2493 gcFIXUP2(ip->port_data, gc); 2494 gcFIXUP2(ip->name, gc); 2495 gcFIXUP2(ip->peeked_read, gc); 2496 gcFIXUP2(ip->peeked_write, gc); 2497 gcFIXUP2(ip->read_handler, gc); 2498 gcFIXUP2(ip->closed_evt, gc); 2499 gcFIXUP2(ip->mref, gc); 2500 gcFIXUP2(ip->output_half, gc); 2501 gcFIXUP2(ip->special, gc); 2502 gcFIXUP2(ip->ungotten_special, gc); 2503 gcFIXUP2(ip->progress_evt, gc); 2504 gcFIXUP2(ip->input_lock, gc); 2505 gcFIXUP2(ip->input_giveup, gc); 2506 gcFIXUP2(ip->input_extras, gc); 2507 gcFIXUP2(ip->input_extras_ready, gc); 2508 gcFIXUP2(ip->unless, gc); 2509 gcFIXUP2(ip->unless_cache, gc); 2510#ifdef WINDOWS_FILE_HANDLES 2511 gcFIXUP2(ip->bufwidths, gc); 2512#endif 2513 2514# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2515 return 0; 2516# else 2517 return 2518 gcBYTES_TO_WORDS(sizeof(Scheme_Input_Port)); 2519# endif 2520#endif 2521} 2522 2523#define input_port_IS_ATOMIC 0 2524#define input_port_IS_CONST_SIZE 1 2525 2526 2527static int output_port_SIZE(void *p, struct NewGC *gc) { 2528#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2529 gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); 2530#else 2531 return 0; 2532#endif 2533} 2534 2535static int output_port_MARK(void *p, struct NewGC *gc) { 2536#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2537 Scheme_Output_Port *op = (Scheme_Output_Port *)p; 2538 2539 gcMARK2(op->p.position_redirect, gc); 2540 gcMARK2(op->sub_type, gc); 2541 gcMARK2(op->port_data, gc); 2542 gcMARK2(op->name, gc); 2543 gcMARK2(op->display_handler, gc); 2544 gcMARK2(op->write_handler, gc); 2545 gcMARK2(op->print_handler, gc); 2546 gcMARK2(op->closed_evt, gc); 2547 gcMARK2(op->mref, gc); 2548 gcMARK2(op->input_half, gc); 2549 2550# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2551 return 0; 2552# else 2553 return 2554 gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); 2555# endif 2556#endif 2557} 2558 2559static int output_port_FIXUP(void *p, struct NewGC *gc) { 2560#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2561 Scheme_Output_Port *op = (Scheme_Output_Port *)p; 2562 2563 gcFIXUP2(op->p.position_redirect, gc); 2564 gcFIXUP2(op->sub_type, gc); 2565 gcFIXUP2(op->port_data, gc); 2566 gcFIXUP2(op->name, gc); 2567 gcFIXUP2(op->display_handler, gc); 2568 gcFIXUP2(op->write_handler, gc); 2569 gcFIXUP2(op->print_handler, gc); 2570 gcFIXUP2(op->closed_evt, gc); 2571 gcFIXUP2(op->mref, gc); 2572 gcFIXUP2(op->input_half, gc); 2573 2574# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2575 return 0; 2576# else 2577 return 2578 gcBYTES_TO_WORDS(sizeof(Scheme_Output_Port)); 2579# endif 2580#endif 2581} 2582 2583#define output_port_IS_ATOMIC 0 2584#define output_port_IS_CONST_SIZE 1 2585 2586 2587static int thread_val_SIZE(void *p, struct NewGC *gc) { 2588#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2589 gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); 2590#else 2591 return 0; 2592#endif 2593} 2594 2595static int thread_val_MARK(void *p, struct NewGC *gc) { 2596#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2597 Scheme_Thread *pr = (Scheme_Thread *)p; 2598 2599 gcMARK2(pr->next, gc); 2600 gcMARK2(pr->prev, gc); 2601 2602 gcMARK2(pr->t_set_parent, gc); 2603 gcMARK2(pr->t_set_next, gc); 2604 gcMARK2(pr->t_set_prev, gc); 2605 2606 MARK_cjs(&pr->cjs, gc); 2607 gcMARK2(pr->decompose_mc, gc); 2608 2609 gcMARK2(pr->cell_values, gc); 2610 gcMARK2(pr->init_config, gc); 2611 gcMARK2(pr->init_break_cell, gc); 2612 2613 if (!pr->runstack_owner 2614 || !GC_merely_accounting() 2615 || (*pr->runstack_owner == pr)) { 2616 Scheme_Object **rs = pr->runstack_start; 2617 gcMARK2( pr->runstack_start, gc); 2618 if (pr->runstack != pr->runstack_start + (pr->runstack - rs)) 2619 pr->runstack = pr->runstack_start + (pr->runstack - rs); 2620 2621 gcMARK2(pr->runstack_saved, gc); 2622 } 2623 gcMARK2(pr->runstack_owner, gc); 2624 gcMARK2(pr->runstack_swapped, gc); 2625 pr->spare_runstack = NULL; /* just in case */ 2626 2627 gcMARK2(pr->meta_prompt, gc); 2628 gcMARK2(pr->meta_continuation, gc); 2629 gcMARK2(pr->acting_barrier_prompt, gc); 2630 2631 gcMARK2(pr->cont_mark_stack_segments, gc); 2632 gcMARK2(pr->cont_mark_stack_owner, gc); 2633 gcMARK2(pr->cont_mark_stack_swapped, gc); 2634 2635 MARK_jmpup(&pr->jmpup_buf, gc); 2636 2637 gcMARK2(pr->dw, gc); 2638 2639 gcMARK2(pr->nester, gc); 2640 gcMARK2(pr->nestee, gc); 2641 2642 gcMARK2(pr->current_ft, gc); 2643 2644 gcMARK2(pr->blocker, gc); 2645 gcMARK2(pr->overflow, gc); 2646 2647 gcMARK2(pr->return_marks_to, gc); 2648 gcMARK2(pr->returned_marks, gc); 2649 2650 gcMARK2(pr->current_mt, gc); 2651 2652 gcMARK2(pr->constant_folding, gc); 2653 gcMARK2(pr->reading_delayed, gc); 2654 2655 gcMARK2(pr->overflow_reply, gc); 2656 2657 gcMARK2(pr->values_buffer, gc); 2658 2659 gcMARK2(pr->tail_buffer, gc); 2660 2661 gcMARK2(pr->ku.eval.wait_expr, gc); 2662 2663 gcMARK2(pr->ku.apply.tail_rator, gc); 2664 gcMARK2(pr->ku.apply.tail_rands, gc); 2665 2666 gcMARK2(pr->ku.multiple.array, gc); 2667 2668 gcMARK2(pr->ku.k.p1, gc); 2669 gcMARK2(pr->ku.k.p2, gc); 2670 gcMARK2(pr->ku.k.p3, gc); 2671 gcMARK2(pr->ku.k.p4, gc); 2672 gcMARK2(pr->ku.k.p5, gc); 2673 2674 gcMARK2(pr->self_for_proc_chaperone, gc); 2675 2676 gcMARK2(pr->kill_data, gc); 2677 gcMARK2(pr->private_kill_data, gc); 2678 gcMARK2(pr->private_kill_next, gc); 2679 2680 gcMARK2(pr->user_tls, gc); 2681 gcMARK2(pr->gmp_tls_data, gc); 2682 2683 gcMARK2(pr->mr_hop, gc); 2684 gcMARK2(pr->mref, gc); 2685 gcMARK2(pr->extra_mrefs, gc); 2686 2687 gcMARK2(pr->name, gc); 2688 2689 gcMARK2(pr->transitive_resumes, gc); 2690 2691 gcMARK2(pr->suspended_box, gc); 2692 gcMARK2(pr->resumed_box, gc); 2693 gcMARK2(pr->dead_box, gc); 2694 gcMARK2(pr->running_box, gc); 2695 gcMARK2(pr->sync_box, gc); 2696 2697 gcMARK2(pr->mbox_first, gc); 2698 gcMARK2(pr->mbox_last, gc); 2699 gcMARK2(pr->mbox_sema, gc); 2700 2701 /* Follow msg_chain for an in-flight message like in place_async_channel_val */ 2702 { 2703 Scheme_Object *cpr = pr->place_channel_msg_chain_in_flight; 2704 while (cpr) { 2705 gcMARK2(SCHEME_CAR(cpr), gc); 2706 cpr = SCHEME_CDR(cpr); 2707 } 2708 } 2709 2710# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2711 return 0; 2712# else 2713 return 2714 gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); 2715# endif 2716#endif 2717} 2718 2719static int thread_val_FIXUP(void *p, struct NewGC *gc) { 2720#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2721 Scheme_Thread *pr = (Scheme_Thread *)p; 2722 2723 gcFIXUP2(pr->next, gc); 2724 gcFIXUP2(pr->prev, gc); 2725 2726 gcFIXUP2(pr->t_set_parent, gc); 2727 gcFIXUP2(pr->t_set_next, gc); 2728 gcFIXUP2(pr->t_set_prev, gc); 2729 2730 FIXUP_cjs(&pr->cjs, gc); 2731 gcFIXUP2(pr->decompose_mc, gc); 2732 2733 gcFIXUP2(pr->cell_values, gc); 2734 gcFIXUP2(pr->init_config, gc); 2735 gcFIXUP2(pr->init_break_cell, gc); 2736 2737 if (!pr->runstack_owner 2738 || !GC_merely_accounting() 2739 || (*pr->runstack_owner == pr)) { 2740 Scheme_Object **rs = pr->runstack_start; 2741 gcFIXUP2_TYPED_NOW(Scheme_Object **, pr->runstack_start, gc); 2742 if (pr->runstack != pr->runstack_start + (pr->runstack - rs)) 2743 pr->runstack = pr->runstack_start + (pr->runstack - rs); 2744 2745 gcFIXUP2(pr->runstack_saved, gc); 2746 } 2747 gcFIXUP2(pr->runstack_owner, gc); 2748 gcFIXUP2(pr->runstack_swapped, gc); 2749 pr->spare_runstack = NULL; /* just in case */ 2750 2751 gcFIXUP2(pr->meta_prompt, gc); 2752 gcFIXUP2(pr->meta_continuation, gc); 2753 gcFIXUP2(pr->acting_barrier_prompt, gc); 2754 2755 gcFIXUP2(pr->cont_mark_stack_segments, gc); 2756 gcFIXUP2(pr->cont_mark_stack_owner, gc); 2757 gcFIXUP2(pr->cont_mark_stack_swapped, gc); 2758 2759 FIXUP_jmpup(&pr->jmpup_buf, gc); 2760 2761 gcFIXUP2(pr->dw, gc); 2762 2763 gcFIXUP2(pr->nester, gc); 2764 gcFIXUP2(pr->nestee, gc); 2765 2766 gcFIXUP2(pr->current_ft, gc); 2767 2768 gcFIXUP2(pr->blocker, gc); 2769 gcFIXUP2(pr->overflow, gc); 2770 2771 gcFIXUP2(pr->return_marks_to, gc); 2772 gcFIXUP2(pr->returned_marks, gc); 2773 2774 gcFIXUP2(pr->current_mt, gc); 2775 2776 gcFIXUP2(pr->constant_folding, gc); 2777 gcFIXUP2(pr->reading_delayed, gc); 2778 2779 gcFIXUP2(pr->overflow_reply, gc); 2780 2781 gcFIXUP2(pr->values_buffer, gc); 2782 2783 gcFIXUP2(pr->tail_buffer, gc); 2784 2785 gcFIXUP2(pr->ku.eval.wait_expr, gc); 2786 2787 gcFIXUP2(pr->ku.apply.tail_rator, gc); 2788 gcFIXUP2(pr->ku.apply.tail_rands, gc); 2789 2790 gcFIXUP2(pr->ku.multiple.array, gc); 2791 2792 gcFIXUP2(pr->ku.k.p1, gc); 2793 gcFIXUP2(pr->ku.k.p2, gc); 2794 gcFIXUP2(pr->ku.k.p3, gc); 2795 gcFIXUP2(pr->ku.k.p4, gc); 2796 gcFIXUP2(pr->ku.k.p5, gc); 2797 2798 gcFIXUP2(pr->self_for_proc_chaperone, gc); 2799 2800 gcFIXUP2(pr->kill_data, gc); 2801 gcFIXUP2(pr->private_kill_data, gc); 2802 gcFIXUP2(pr->private_kill_next, gc); 2803 2804 gcFIXUP2(pr->user_tls, gc); 2805 gcFIXUP2(pr->gmp_tls_data, gc); 2806 2807 gcFIXUP2(pr->mr_hop, gc); 2808 gcFIXUP2(pr->mref, gc); 2809 gcFIXUP2(pr->extra_mrefs, gc); 2810 2811 gcFIXUP2(pr->name, gc); 2812 2813 gcFIXUP2(pr->transitive_resumes, gc); 2814 2815 gcFIXUP2(pr->suspended_box, gc); 2816 gcFIXUP2(pr->resumed_box, gc); 2817 gcFIXUP2(pr->dead_box, gc); 2818 gcFIXUP2(pr->running_box, gc); 2819 gcFIXUP2(pr->sync_box, gc); 2820 2821 gcFIXUP2(pr->mbox_first, gc); 2822 gcFIXUP2(pr->mbox_last, gc); 2823 gcFIXUP2(pr->mbox_sema, gc); 2824 2825 /* Follow msg_chain for an in-flight message like in place_async_channel_val */ 2826 { 2827 Scheme_Object *cpr = pr->place_channel_msg_chain_in_flight; 2828 while (cpr) { 2829 gcFIXUP2(SCHEME_CAR(cpr), gc); 2830 cpr = SCHEME_CDR(cpr); 2831 } 2832 } 2833 2834# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2835 return 0; 2836# else 2837 return 2838 gcBYTES_TO_WORDS(sizeof(Scheme_Thread)); 2839# endif 2840#endif 2841} 2842 2843#define thread_val_IS_ATOMIC 0 2844#define thread_val_IS_CONST_SIZE 1 2845 2846 2847static int runstack_val_SIZE(void *p, struct NewGC *gc) { 2848#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2849 intptr_t *s = (intptr_t *)p; 2850 s[1]; 2851#else 2852 return 0; 2853#endif 2854} 2855 2856static int runstack_val_MARK(void *p, struct NewGC *gc) { 2857#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2858 intptr_t *s = (intptr_t *)p; 2859 void **a, **b; 2860 a = (void **)s + RUNSTACK_HEADER_FIELDS + s[2]; 2861 b = (void **)s + RUNSTACK_HEADER_FIELDS + s[3]; 2862 while (a < b) { 2863 gcMARK2(*a, gc); 2864 a++; 2865 } 2866 2867 /* Zero out the part that we didn't mark, in case it becomes 2868 live later. */ 2869 a = (void **)s + RUNSTACK_HEADER_FIELDS; 2870 b = (void **)s + RUNSTACK_HEADER_FIELDS + s[2]; 2871 while (a < b) { 2872 *a = RUNSTACK_ZERO_VAL; 2873 a++; 2874 } 2875 a = (void **)s + RUNSTACK_HEADER_FIELDS + s[3]; 2876 b = (void **)s + RUNSTACK_HEADER_FIELDS + (s[1] - RUNSTACK_HEADER_FIELDS); 2877 while (a < b) { 2878 *a = RUNSTACK_ZERO_VAL; 2879 a++; 2880 } 2881 2882# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2883 return 0; 2884# else 2885 return 2886 s[1]; 2887# endif 2888#endif 2889} 2890 2891static int runstack_val_FIXUP(void *p, struct NewGC *gc) { 2892#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2893 intptr_t *s = (intptr_t *)p; 2894 void **a, **b; 2895 a = (void **)s + RUNSTACK_HEADER_FIELDS + s[2]; 2896 b = (void **)s + RUNSTACK_HEADER_FIELDS + s[3]; 2897 while (a < b) { 2898 gcFIXUP2(*a, gc); 2899 a++; 2900 } 2901 2902 2903# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2904 return 0; 2905# else 2906 return 2907 s[1]; 2908# endif 2909#endif 2910} 2911 2912#define runstack_val_IS_ATOMIC 0 2913#define runstack_val_IS_CONST_SIZE 0 2914 2915 2916static int prompt_val_SIZE(void *p, struct NewGC *gc) { 2917#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2918 gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); 2919#else 2920 return 0; 2921#endif 2922} 2923 2924static int prompt_val_MARK(void *p, struct NewGC *gc) { 2925#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2926 Scheme_Prompt *pr = (Scheme_Prompt *)p; 2927 gcMARK2(pr->boundary_overflow_id, gc); 2928 if (!GC_merely_accounting()) { 2929 if (pr->is_barrier) 2930 gcMARK2(pr->u.runstack_boundary_start_ref, gc); 2931 else 2932 gcMARK2(pr->u.runstack_boundary_start, gc); 2933 } 2934 gcMARK2(pr->tag, gc); 2935 gcMARK2(pr->id, gc); 2936# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2937 return 0; 2938# else 2939 return 2940 gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); 2941# endif 2942#endif 2943} 2944 2945static int prompt_val_FIXUP(void *p, struct NewGC *gc) { 2946#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2947 Scheme_Prompt *pr = (Scheme_Prompt *)p; 2948 gcFIXUP2(pr->boundary_overflow_id, gc); 2949 if (!GC_merely_accounting()) { 2950 if (pr->is_barrier) 2951 gcFIXUP2(pr->u.runstack_boundary_start_ref, gc); 2952 else 2953 gcFIXUP2(pr->u.runstack_boundary_start, gc); 2954 } 2955 gcFIXUP2(pr->tag, gc); 2956 gcFIXUP2(pr->id, gc); 2957# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2958 return 0; 2959# else 2960 return 2961 gcBYTES_TO_WORDS(sizeof(Scheme_Prompt)); 2962# endif 2963#endif 2964} 2965 2966#define prompt_val_IS_ATOMIC 0 2967#define prompt_val_IS_CONST_SIZE 1 2968 2969 2970static int cont_mark_set_val_SIZE(void *p, struct NewGC *gc) { 2971#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 2972 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); 2973#else 2974 return 0; 2975#endif 2976} 2977 2978static int cont_mark_set_val_MARK(void *p, struct NewGC *gc) { 2979#ifndef GC_NO_MARK_PROCEDURE_NEEDED 2980 Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p; 2981 gcMARK2(s->chain, gc); 2982 gcMARK2(s->native_stack_trace, gc); 2983 2984# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 2985 return 0; 2986# else 2987 return 2988 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); 2989# endif 2990#endif 2991} 2992 2993static int cont_mark_set_val_FIXUP(void *p, struct NewGC *gc) { 2994#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 2995 Scheme_Cont_Mark_Set *s = (Scheme_Cont_Mark_Set *)p; 2996 gcFIXUP2(s->chain, gc); 2997 gcFIXUP2(s->native_stack_trace, gc); 2998 2999# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3000 return 0; 3001# else 3002 return 3003 gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Set)); 3004# endif 3005#endif 3006} 3007 3008#define cont_mark_set_val_IS_ATOMIC 0 3009#define cont_mark_set_val_IS_CONST_SIZE 1 3010 3011 3012static int sema_val_SIZE(void *p, struct NewGC *gc) { 3013#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3014 gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); 3015#else 3016 return 0; 3017#endif 3018} 3019 3020static int sema_val_MARK(void *p, struct NewGC *gc) { 3021#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3022 Scheme_Sema *s = (Scheme_Sema *)p; 3023 3024 gcMARK2(s->first, gc); 3025 gcMARK2(s->last, gc); 3026 3027# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3028 return 0; 3029# else 3030 return 3031 gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); 3032# endif 3033#endif 3034} 3035 3036static int sema_val_FIXUP(void *p, struct NewGC *gc) { 3037#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3038 Scheme_Sema *s = (Scheme_Sema *)p; 3039 3040 gcFIXUP2(s->first, gc); 3041 gcFIXUP2(s->last, gc); 3042 3043# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3044 return 0; 3045# else 3046 return 3047 gcBYTES_TO_WORDS(sizeof(Scheme_Sema)); 3048# endif 3049#endif 3050} 3051 3052#define sema_val_IS_ATOMIC 0 3053#define sema_val_IS_CONST_SIZE 1 3054 3055 3056static int channel_val_SIZE(void *p, struct NewGC *gc) { 3057#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3058 gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); 3059#else 3060 return 0; 3061#endif 3062} 3063 3064static int channel_val_MARK(void *p, struct NewGC *gc) { 3065#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3066 Scheme_Channel *s = (Scheme_Channel *)p; 3067 3068 gcMARK2(s->get_first, gc); 3069 gcMARK2(s->get_last, gc); 3070 gcMARK2(s->put_first, gc); 3071 gcMARK2(s->put_last, gc); 3072 3073# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3074 return 0; 3075# else 3076 return 3077 gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); 3078# endif 3079#endif 3080} 3081 3082static int channel_val_FIXUP(void *p, struct NewGC *gc) { 3083#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3084 Scheme_Channel *s = (Scheme_Channel *)p; 3085 3086 gcFIXUP2(s->get_first, gc); 3087 gcFIXUP2(s->get_last, gc); 3088 gcFIXUP2(s->put_first, gc); 3089 gcFIXUP2(s->put_last, gc); 3090 3091# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3092 return 0; 3093# else 3094 return 3095 gcBYTES_TO_WORDS(sizeof(Scheme_Channel)); 3096# endif 3097#endif 3098} 3099 3100#define channel_val_IS_ATOMIC 0 3101#define channel_val_IS_CONST_SIZE 1 3102 3103 3104static int channel_put_val_SIZE(void *p, struct NewGC *gc) { 3105#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3106 gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); 3107#else 3108 return 0; 3109#endif 3110} 3111 3112static int channel_put_val_MARK(void *p, struct NewGC *gc) { 3113#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3114 Scheme_Channel_Put *s = (Scheme_Channel_Put *)p; 3115 3116 gcMARK2(s->ch, gc); 3117 gcMARK2(s->val, gc); 3118 3119# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3120 return 0; 3121# else 3122 return 3123 gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); 3124# endif 3125#endif 3126} 3127 3128static int channel_put_val_FIXUP(void *p, struct NewGC *gc) { 3129#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3130 Scheme_Channel_Put *s = (Scheme_Channel_Put *)p; 3131 3132 gcFIXUP2(s->ch, gc); 3133 gcFIXUP2(s->val, gc); 3134 3135# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3136 return 0; 3137# else 3138 return 3139 gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Put)); 3140# endif 3141#endif 3142} 3143 3144#define channel_put_val_IS_ATOMIC 0 3145#define channel_put_val_IS_CONST_SIZE 1 3146 3147 3148static int hash_table_val_SIZE(void *p, struct NewGC *gc) { 3149#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3150 gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); 3151#else 3152 return 0; 3153#endif 3154} 3155 3156static int hash_table_val_MARK(void *p, struct NewGC *gc) { 3157#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3158 Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p; 3159 3160 gcMARK2(ht->keys, gc); 3161 gcMARK2(ht->vals, gc); 3162 gcMARK2(ht->mutex, gc); 3163 3164# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3165 return 0; 3166# else 3167 return 3168 gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); 3169# endif 3170#endif 3171} 3172 3173static int hash_table_val_FIXUP(void *p, struct NewGC *gc) { 3174#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3175 Scheme_Hash_Table *ht = (Scheme_Hash_Table *)p; 3176 3177 gcFIXUP2(ht->keys, gc); 3178 gcFIXUP2(ht->vals, gc); 3179 gcFIXUP2(ht->mutex, gc); 3180 3181# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3182 return 0; 3183# else 3184 return 3185 gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Table)); 3186# endif 3187#endif 3188} 3189 3190#define hash_table_val_IS_ATOMIC 0 3191#define hash_table_val_IS_CONST_SIZE 1 3192 3193 3194static int bucket_table_val_SIZE(void *p, struct NewGC *gc) { 3195#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3196 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); 3197#else 3198 return 0; 3199#endif 3200} 3201 3202static int bucket_table_val_MARK(void *p, struct NewGC *gc) { 3203#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3204 Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p; 3205 3206 gcMARK2(ht->buckets, gc); 3207 gcMARK2(ht->mutex, gc); 3208 3209# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3210 return 0; 3211# else 3212 return 3213 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); 3214# endif 3215#endif 3216} 3217 3218static int bucket_table_val_FIXUP(void *p, struct NewGC *gc) { 3219#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3220 Scheme_Bucket_Table *ht = (Scheme_Bucket_Table *)p; 3221 3222 gcFIXUP2(ht->buckets, gc); 3223 gcFIXUP2(ht->mutex, gc); 3224 3225# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3226 return 0; 3227# else 3228 return 3229 gcBYTES_TO_WORDS(sizeof(Scheme_Bucket_Table)); 3230# endif 3231#endif 3232} 3233 3234#define bucket_table_val_IS_ATOMIC 0 3235#define bucket_table_val_IS_CONST_SIZE 1 3236 3237 3238static int env_val_SIZE(void *p, struct NewGC *gc) { 3239#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3240 gcBYTES_TO_WORDS(sizeof(Scheme_Env)); 3241#else 3242 return 0; 3243#endif 3244} 3245 3246static int env_val_MARK(void *p, struct NewGC *gc) { 3247#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3248 Scheme_Env *e = (Scheme_Env *)p; 3249 3250 gcMARK2(e->namespace, gc); 3251 gcMARK2(e->instance, gc); 3252 gcMARK2(e->protected, gc); 3253# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3254 return 0; 3255# else 3256 return 3257 gcBYTES_TO_WORDS(sizeof(Scheme_Env)); 3258# endif 3259#endif 3260} 3261 3262static int env_val_FIXUP(void *p, struct NewGC *gc) { 3263#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3264 Scheme_Env *e = (Scheme_Env *)p; 3265 3266 gcFIXUP2(e->namespace, gc); 3267 gcFIXUP2(e->instance, gc); 3268 gcFIXUP2(e->protected, gc); 3269# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3270 return 0; 3271# else 3272 return 3273 gcBYTES_TO_WORDS(sizeof(Scheme_Env)); 3274# endif 3275#endif 3276} 3277 3278#define env_val_IS_ATOMIC 0 3279#define env_val_IS_CONST_SIZE 1 3280 3281 3282static int startup_env_val_SIZE(void *p, struct NewGC *gc) { 3283#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3284 gcBYTES_TO_WORDS(sizeof(Scheme_Startup_Env)); 3285#else 3286 return 0; 3287#endif 3288} 3289 3290static int startup_env_val_MARK(void *p, struct NewGC *gc) { 3291#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3292 Scheme_Startup_Env *e = (Scheme_Startup_Env *)p; 3293 3294 gcMARK2(e->current_table, gc); 3295 gcMARK2(e->primitive_tables, gc); 3296 gcMARK2(e->all_primitives_table, gc); 3297 gcMARK2(e->primitive_ids_table, gc); 3298# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3299 return 0; 3300# else 3301 return 3302 gcBYTES_TO_WORDS(sizeof(Scheme_Startup_Env)); 3303# endif 3304#endif 3305} 3306 3307static int startup_env_val_FIXUP(void *p, struct NewGC *gc) { 3308#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3309 Scheme_Startup_Env *e = (Scheme_Startup_Env *)p; 3310 3311 gcFIXUP2(e->current_table, gc); 3312 gcFIXUP2(e->primitive_tables, gc); 3313 gcFIXUP2(e->all_primitives_table, gc); 3314 gcFIXUP2(e->primitive_ids_table, gc); 3315# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3316 return 0; 3317# else 3318 return 3319 gcBYTES_TO_WORDS(sizeof(Scheme_Startup_Env)); 3320# endif 3321#endif 3322} 3323 3324#define startup_env_val_IS_ATOMIC 0 3325#define startup_env_val_IS_CONST_SIZE 1 3326 3327 3328static int random_state_val_SIZE(void *p, struct NewGC *gc) { 3329#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3330 gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); 3331#else 3332 return 0; 3333#endif 3334} 3335 3336static int random_state_val_MARK(void *p, struct NewGC *gc) { 3337#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3338# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3339 return 0; 3340# else 3341 return 3342 gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); 3343# endif 3344#endif 3345} 3346 3347static int random_state_val_FIXUP(void *p, struct NewGC *gc) { 3348#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3349# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3350 return 0; 3351# else 3352 return 3353 gcBYTES_TO_WORDS(sizeof(Scheme_Random_State)); 3354# endif 3355#endif 3356} 3357 3358#define random_state_val_IS_ATOMIC 1 3359#define random_state_val_IS_CONST_SIZE 1 3360 3361 3362static int prefix_val_SIZE(void *p, struct NewGC *gc) { 3363#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3364 Scheme_Prefix *pf = (Scheme_Prefix *)p; 3365 gcBYTES_TO_WORDS((sizeof(Scheme_Prefix) 3366 + ((pf->num_slots-mzFLEX_DELTA) * sizeof(Scheme_Object *)) 3367 + ((((pf->num_slots + 31) / 32) 3368 * sizeof(int)))); 3369#else 3370 return 0; 3371#endif 3372} 3373 3374static int prefix_val_MARK(void *p, struct NewGC *gc) { 3375#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3376 Scheme_Prefix *pf = (Scheme_Prefix *)p; 3377 int i; 3378 for (i = pf->num_slots; i--; ) 3379 gcMARK2(pf->a[i], gc); 3380# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3381 return 0; 3382# else 3383 return 3384 gcBYTES_TO_WORDS((sizeof(Scheme_Prefix) 3385 + ((pf->num_slots-mzFLEX_DELTA) * sizeof(Scheme_Object *)) 3386 + ((((pf->num_slots + 31) / 32) 3387 * sizeof(int)))); 3388# endif 3389#endif 3390} 3391 3392static int prefix_val_FIXUP(void *p, struct NewGC *gc) { 3393#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3394 Scheme_Prefix *pf = (Scheme_Prefix *)p; 3395 int i; 3396 for (i = pf->num_slots; i--; ) 3397 gcFIXUP2(pf->a[i], gc); 3398# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3399 return 0; 3400# else 3401 return 3402 gcBYTES_TO_WORDS((sizeof(Scheme_Prefix) 3403 + ((pf->num_slots-mzFLEX_DELTA) * sizeof(Scheme_Object *)) 3404 + ((((pf->num_slots + 31) / 32) 3405 * sizeof(int)))); 3406# endif 3407#endif 3408} 3409 3410#define prefix_val_IS_ATOMIC 0 3411#define prefix_val_IS_CONST_SIZE 0 3412 3413 3414static int svector_val_SIZE(void *p, struct NewGC *gc) { 3415#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3416 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 3417#else 3418 return 0; 3419#endif 3420} 3421 3422static int svector_val_MARK(void *p, struct NewGC *gc) { 3423#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3424 Scheme_Object *o = (Scheme_Object *)p; 3425 3426 gcMARK2(SCHEME_SVEC_VEC(o), gc); 3427 3428# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3429 return 0; 3430# else 3431 return 3432 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 3433# endif 3434#endif 3435} 3436 3437static int svector_val_FIXUP(void *p, struct NewGC *gc) { 3438#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3439 Scheme_Object *o = (Scheme_Object *)p; 3440 3441 gcFIXUP2(SCHEME_SVEC_VEC(o), gc); 3442 3443# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3444 return 0; 3445# else 3446 return 3447 gcBYTES_TO_WORDS(sizeof(Scheme_Simple_Object)); 3448# endif 3449#endif 3450} 3451 3452#define svector_val_IS_ATOMIC 0 3453#define svector_val_IS_CONST_SIZE 1 3454 3455 3456static int stx_val_SIZE(void *p, struct NewGC *gc) { 3457#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3458 gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); 3459#else 3460 return 0; 3461#endif 3462} 3463 3464static int stx_val_MARK(void *p, struct NewGC *gc) { 3465#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3466 Scheme_Stx *stx = (Scheme_Stx *)p; 3467 gcMARK2(stx->val, gc); 3468 gcMARK2(stx->srcloc, gc); 3469 gcMARK2(stx->props, gc); 3470# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3471 return 0; 3472# else 3473 return 3474 gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); 3475# endif 3476#endif 3477} 3478 3479static int stx_val_FIXUP(void *p, struct NewGC *gc) { 3480#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3481 Scheme_Stx *stx = (Scheme_Stx *)p; 3482 gcFIXUP2(stx->val, gc); 3483 gcFIXUP2(stx->srcloc, gc); 3484 gcFIXUP2(stx->props, gc); 3485# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3486 return 0; 3487# else 3488 return 3489 gcBYTES_TO_WORDS(sizeof(Scheme_Stx)); 3490# endif 3491#endif 3492} 3493 3494#define stx_val_IS_ATOMIC 0 3495#define stx_val_IS_CONST_SIZE 1 3496 3497 3498static int linklet_val_SIZE(void *p, struct NewGC *gc) { 3499#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3500 gcBYTES_TO_WORDS(sizeof(Scheme_Linklet)); 3501#else 3502 return 0; 3503#endif 3504} 3505 3506static int linklet_val_MARK(void *p, struct NewGC *gc) { 3507#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3508 Scheme_Linklet *l = (Scheme_Linklet *)p; 3509 3510 gcMARK2(l->name, gc); 3511 gcMARK2(l->importss, gc); 3512 gcMARK2(l->import_shapes, gc); 3513 gcMARK2(l->defns, gc); 3514 gcMARK2(l->source_names, gc); 3515 gcMARK2(l->bodies, gc); 3516 gcMARK2(l->constants, gc); 3517 gcMARK2(l->static_prefix, gc); 3518 gcMARK2(l->native_lambdas, gc); 3519# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3520 return 0; 3521# else 3522 return 3523 gcBYTES_TO_WORDS(sizeof(Scheme_Linklet)); 3524# endif 3525#endif 3526} 3527 3528static int linklet_val_FIXUP(void *p, struct NewGC *gc) { 3529#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3530 Scheme_Linklet *l = (Scheme_Linklet *)p; 3531 3532 gcFIXUP2(l->name, gc); 3533 gcFIXUP2(l->importss, gc); 3534 gcFIXUP2(l->import_shapes, gc); 3535 gcFIXUP2(l->defns, gc); 3536 gcFIXUP2(l->source_names, gc); 3537 gcFIXUP2(l->bodies, gc); 3538 gcFIXUP2(l->constants, gc); 3539 gcFIXUP2(l->static_prefix, gc); 3540 gcFIXUP2(l->native_lambdas, gc); 3541# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3542 return 0; 3543# else 3544 return 3545 gcBYTES_TO_WORDS(sizeof(Scheme_Linklet)); 3546# endif 3547#endif 3548} 3549 3550#define linklet_val_IS_ATOMIC 0 3551#define linklet_val_IS_CONST_SIZE 1 3552 3553 3554static int instance_val_SIZE(void *p, struct NewGC *gc) { 3555#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3556 gcBYTES_TO_WORDS(sizeof(Scheme_Instance)); 3557#else 3558 return 0; 3559#endif 3560} 3561 3562static int instance_val_MARK(void *p, struct NewGC *gc) { 3563#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3564 Scheme_Instance *i = (Scheme_Instance *)p; 3565 3566 gcMARK2(i->variables.a, gc); 3567 gcMARK2(i->weak_self_link, gc); 3568 gcMARK2(i->source_names, gc); 3569 gcMARK2(i->name, gc); 3570 gcMARK2(i->data, gc); 3571# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3572 return 0; 3573# else 3574 return 3575 gcBYTES_TO_WORDS(sizeof(Scheme_Instance)); 3576# endif 3577#endif 3578} 3579 3580static int instance_val_FIXUP(void *p, struct NewGC *gc) { 3581#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3582 Scheme_Instance *i = (Scheme_Instance *)p; 3583 3584 gcFIXUP2(i->variables.a, gc); 3585 gcFIXUP2(i->weak_self_link, gc); 3586 gcFIXUP2(i->source_names, gc); 3587 gcFIXUP2(i->name, gc); 3588 gcFIXUP2(i->data, gc); 3589# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3590 return 0; 3591# else 3592 return 3593 gcBYTES_TO_WORDS(sizeof(Scheme_Instance)); 3594# endif 3595#endif 3596} 3597 3598#define instance_val_IS_ATOMIC 0 3599#define instance_val_IS_CONST_SIZE 1 3600 3601 3602static int guard_val_SIZE(void *p, struct NewGC *gc) { 3603#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3604 gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); 3605#else 3606 return 0; 3607#endif 3608} 3609 3610static int guard_val_MARK(void *p, struct NewGC *gc) { 3611#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3612 Scheme_Security_Guard *g = (Scheme_Security_Guard *)p; 3613 3614 gcMARK2(g->parent, gc); 3615 gcMARK2(g->file_proc, gc); 3616 gcMARK2(g->network_proc, gc); 3617 gcMARK2(g->link_proc, gc); 3618# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3619 return 0; 3620# else 3621 return 3622 gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); 3623# endif 3624#endif 3625} 3626 3627static int guard_val_FIXUP(void *p, struct NewGC *gc) { 3628#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3629 Scheme_Security_Guard *g = (Scheme_Security_Guard *)p; 3630 3631 gcFIXUP2(g->parent, gc); 3632 gcFIXUP2(g->file_proc, gc); 3633 gcFIXUP2(g->network_proc, gc); 3634 gcFIXUP2(g->link_proc, gc); 3635# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3636 return 0; 3637# else 3638 return 3639 gcBYTES_TO_WORDS(sizeof(Scheme_Security_Guard)); 3640# endif 3641#endif 3642} 3643 3644#define guard_val_IS_ATOMIC 0 3645#define guard_val_IS_CONST_SIZE 1 3646 3647 3648static int buf_holder_SIZE(void *p, struct NewGC *gc) { 3649#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3650 gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); 3651#else 3652 return 0; 3653#endif 3654} 3655 3656static int buf_holder_MARK(void *p, struct NewGC *gc) { 3657#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3658 Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p; 3659 3660 MARK_jmpup(&h->buf, gc); 3661 3662# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3663 return 0; 3664# else 3665 return 3666 gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); 3667# endif 3668#endif 3669} 3670 3671static int buf_holder_FIXUP(void *p, struct NewGC *gc) { 3672#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3673 Scheme_Jumpup_Buf_Holder *h = (Scheme_Jumpup_Buf_Holder *)p; 3674 3675 FIXUP_jmpup(&h->buf, gc); 3676 3677# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3678 return 0; 3679# else 3680 return 3681 gcBYTES_TO_WORDS(sizeof(Scheme_Jumpup_Buf_Holder)); 3682# endif 3683#endif 3684} 3685 3686#define buf_holder_IS_ATOMIC 0 3687#define buf_holder_IS_CONST_SIZE 1 3688 3689 3690static int mark_inspector_SIZE(void *p, struct NewGC *gc) { 3691#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3692 gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); 3693#else 3694 return 0; 3695#endif 3696} 3697 3698static int mark_inspector_MARK(void *p, struct NewGC *gc) { 3699#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3700 Scheme_Inspector *i = (Scheme_Inspector *)p; 3701 gcMARK2(i->superior, gc); 3702# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3703 return 0; 3704# else 3705 return 3706 gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); 3707# endif 3708#endif 3709} 3710 3711static int mark_inspector_FIXUP(void *p, struct NewGC *gc) { 3712#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3713 Scheme_Inspector *i = (Scheme_Inspector *)p; 3714 gcFIXUP2(i->superior, gc); 3715# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3716 return 0; 3717# else 3718 return 3719 gcBYTES_TO_WORDS(sizeof(Scheme_Inspector)); 3720# endif 3721#endif 3722} 3723 3724#define mark_inspector_IS_ATOMIC 0 3725#define mark_inspector_IS_CONST_SIZE 1 3726 3727 3728static int mark_pipe_SIZE(void *p, struct NewGC *gc) { 3729#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3730 gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); 3731#else 3732 return 0; 3733#endif 3734} 3735 3736static int mark_pipe_MARK(void *p, struct NewGC *gc) { 3737#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3738 Scheme_Pipe *pp = (Scheme_Pipe *)p; 3739 3740 gcMARK2(pp->buf, gc); 3741 gcMARK2(pp->wakeup_on_read, gc); 3742 gcMARK2(pp->wakeup_on_write, gc); 3743 3744# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3745 return 0; 3746# else 3747 return 3748 gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); 3749# endif 3750#endif 3751} 3752 3753static int mark_pipe_FIXUP(void *p, struct NewGC *gc) { 3754#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3755 Scheme_Pipe *pp = (Scheme_Pipe *)p; 3756 3757 gcFIXUP2(pp->buf, gc); 3758 gcFIXUP2(pp->wakeup_on_read, gc); 3759 gcFIXUP2(pp->wakeup_on_write, gc); 3760 3761# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3762 return 0; 3763# else 3764 return 3765 gcBYTES_TO_WORDS(sizeof(Scheme_Pipe)); 3766# endif 3767#endif 3768} 3769 3770#define mark_pipe_IS_ATOMIC 0 3771#define mark_pipe_IS_CONST_SIZE 1 3772 3773 3774static int mark_logger_SIZE(void *p, struct NewGC *gc) { 3775#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3776 gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); 3777#else 3778 return 0; 3779#endif 3780} 3781 3782static int mark_logger_MARK(void *p, struct NewGC *gc) { 3783#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3784 Scheme_Logger *l = (Scheme_Logger *)p; 3785 gcMARK2(l->name, gc); 3786 gcMARK2(l->parent, gc); 3787 gcMARK2(l->want_name_level_cache, gc); 3788 gcMARK2(l->root_timestamp, gc); 3789 gcMARK2(l->syslog_level, gc); 3790 gcMARK2(l->stderr_level, gc); 3791 gcMARK2(l->stdout_level, gc); 3792 gcMARK2(l->propagate_level, gc); 3793 gcMARK2(l->readers, gc); 3794# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3795 return 0; 3796# else 3797 return 3798 gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); 3799# endif 3800#endif 3801} 3802 3803static int mark_logger_FIXUP(void *p, struct NewGC *gc) { 3804#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3805 Scheme_Logger *l = (Scheme_Logger *)p; 3806 gcFIXUP2(l->name, gc); 3807 gcFIXUP2(l->parent, gc); 3808 gcFIXUP2(l->want_name_level_cache, gc); 3809 gcFIXUP2(l->root_timestamp, gc); 3810 gcFIXUP2(l->syslog_level, gc); 3811 gcFIXUP2(l->stderr_level, gc); 3812 gcFIXUP2(l->stdout_level, gc); 3813 gcFIXUP2(l->propagate_level, gc); 3814 gcFIXUP2(l->readers, gc); 3815# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3816 return 0; 3817# else 3818 return 3819 gcBYTES_TO_WORDS(sizeof(Scheme_Logger)); 3820# endif 3821#endif 3822} 3823 3824#define mark_logger_IS_ATOMIC 0 3825#define mark_logger_IS_CONST_SIZE 1 3826 3827 3828static int mark_log_reader_SIZE(void *p, struct NewGC *gc) { 3829#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3830 gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); 3831#else 3832 return 0; 3833#endif 3834} 3835 3836static int mark_log_reader_MARK(void *p, struct NewGC *gc) { 3837#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3838 Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p; 3839 gcMARK2(lr->level, gc); 3840 gcMARK2(lr->sema, gc); 3841 gcMARK2(lr->head, gc); 3842 gcMARK2(lr->tail, gc); 3843# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3844 return 0; 3845# else 3846 return 3847 gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); 3848# endif 3849#endif 3850} 3851 3852static int mark_log_reader_FIXUP(void *p, struct NewGC *gc) { 3853#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3854 Scheme_Log_Reader *lr = (Scheme_Log_Reader *)p; 3855 gcFIXUP2(lr->level, gc); 3856 gcFIXUP2(lr->sema, gc); 3857 gcFIXUP2(lr->head, gc); 3858 gcFIXUP2(lr->tail, gc); 3859# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3860 return 0; 3861# else 3862 return 3863 gcBYTES_TO_WORDS(sizeof(Scheme_Log_Reader)); 3864# endif 3865#endif 3866} 3867 3868#define mark_log_reader_IS_ATOMIC 0 3869#define mark_log_reader_IS_CONST_SIZE 1 3870 3871 3872static int struct_proc_shape_SIZE(void *p, struct NewGC *gc) { 3873#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS 3874 gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Proc_Shape)); 3875#else 3876 return 0; 3877#endif 3878} 3879 3880static int struct_proc_shape_MARK(void *p, struct NewGC *gc) { 3881#ifndef GC_NO_MARK_PROCEDURE_NEEDED 3882 Scheme_Struct_Proc_Shape *s = (Scheme_Struct_Proc_Shape *)p; 3883 gcMARK2(s->identity, gc); 3884# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3885 return 0; 3886# else 3887 return 3888 gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Proc_Shape)); 3889# endif 3890#endif 3891} 3892 3893static int struct_proc_shape_FIXUP(void *p, struct NewGC *gc) { 3894#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED 3895 Scheme_Struct_Proc_Shape *s = (Scheme_Struct_Proc_Shape *)p; 3896 gcFIXUP2(s->identity, gc); 3897# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS 3898 return 0; 3899# else 3900 return 3901 gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Proc_Shape)); 3902# endif 3903#endif 3904} 3905 3906#define struct_proc_shape_IS_ATOMIC 0 3907#define struct_proc_shape_IS_CONST_SIZE 1 3908 3909 3910