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