1/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
2
3#ifdef MZ_USE_PLACES
4static int mark_serialized_struct_val_SIZE(void *p, struct NewGC *gc) {
5#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
6  Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
7  int num_slots = s->num_slots;
8
9  gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
10		    + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
11#else
12  return 0;
13#endif
14}
15
16static int mark_serialized_struct_val_MARK(void *p, struct NewGC *gc) {
17#ifndef GC_NO_MARK_PROCEDURE_NEEDED
18  Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
19  int num_slots = s->num_slots;
20
21  int i;
22
23  gcMARK2(s->prefab_key, gc);
24
25  for(i = num_slots; i--; )
26    gcMARK2(s->slots[i], gc);
27
28# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
29  return 0;
30# else
31  return
32  gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
33		    + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
34# endif
35#endif
36}
37
38static int mark_serialized_struct_val_FIXUP(void *p, struct NewGC *gc) {
39#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
40  Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
41  int num_slots = s->num_slots;
42
43  int i;
44
45  gcFIXUP2(s->prefab_key, gc);
46
47  for(i = num_slots; i--; )
48    gcFIXUP2(s->slots[i], gc);
49
50# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
51  return 0;
52# else
53  return
54  gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
55		    + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
56# endif
57#endif
58}
59
60#define mark_serialized_struct_val_IS_ATOMIC 0
61#define mark_serialized_struct_val_IS_CONST_SIZE 0
62
63#endif
64
65static int mark_struct_val_SIZE(void *p, struct NewGC *gc) {
66#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
67  Scheme_Structure *s = (Scheme_Structure *)p;
68  int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
69
70  gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
71		    + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
72#else
73  return 0;
74#endif
75}
76
77static int mark_struct_val_MARK(void *p, struct NewGC *gc) {
78#ifndef GC_NO_MARK_PROCEDURE_NEEDED
79  Scheme_Structure *s = (Scheme_Structure *)p;
80  int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
81
82  int i;
83
84  gcMARK2( s->stype, gc);
85
86  for(i = num_slots; i--; )
87    gcMARK2(s->slots[i], gc);
88
89# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
90  return 0;
91# else
92  return
93  gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
94		    + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
95# endif
96#endif
97}
98
99static int mark_struct_val_FIXUP(void *p, struct NewGC *gc) {
100#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
101  Scheme_Structure *s = (Scheme_Structure *)p;
102  int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
103
104  int i;
105
106  gcFIXUP2_TYPED_NOW(Scheme_Struct_Type *, s->stype, gc);
107
108  for(i = num_slots; i--; )
109    gcFIXUP2(s->slots[i], gc);
110
111# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
112  return 0;
113# else
114  return
115  gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
116		    + ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
117# endif
118#endif
119}
120
121#define mark_struct_val_IS_ATOMIC 0
122#define mark_struct_val_IS_CONST_SIZE 0
123
124
125static int mark_struct_type_val_SIZE(void *p, struct NewGC *gc) {
126#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
127  Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
128
129  gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
130		    + ((t->name_pos + 1 - mzFLEX_DELTA)
131                       * sizeof(Scheme_Struct_Type *))));
132#else
133  return 0;
134#endif
135}
136
137static int mark_struct_type_val_MARK(void *p, struct NewGC *gc) {
138#ifndef GC_NO_MARK_PROCEDURE_NEEDED
139  Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
140
141  int i;
142  for (i = t->name_pos + 1; i--; ) {
143    gcMARK2(t->parent_types[i], gc);
144  }
145  gcMARK2(t->name, gc);
146  gcMARK2(t->inspector, gc);
147  gcMARK2(t->accessor, gc);
148  gcMARK2(t->mutator, gc);
149  gcMARK2(t->prefab_key, gc);
150  gcMARK2(t->uninit_val, gc);
151  gcMARK2(t->props, gc);
152  gcMARK2(t->proc_attr, gc);
153  gcMARK2(t->guard, gc);
154  gcMARK2(t->immutables, gc);
155
156# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
157  return 0;
158# else
159  return
160  gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
161		    + ((t->name_pos + 1 - mzFLEX_DELTA)
162                       * sizeof(Scheme_Struct_Type *))));
163# endif
164#endif
165}
166
167static int mark_struct_type_val_FIXUP(void *p, struct NewGC *gc) {
168#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
169  Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
170
171  int i;
172  for (i = t->name_pos + 1; i--; ) {
173    gcFIXUP2(t->parent_types[i], gc);
174  }
175  gcFIXUP2(t->name, gc);
176  gcFIXUP2(t->inspector, gc);
177  gcFIXUP2(t->accessor, gc);
178  gcFIXUP2(t->mutator, gc);
179  gcFIXUP2(t->prefab_key, gc);
180  gcFIXUP2(t->uninit_val, gc);
181  gcFIXUP2(t->props, gc);
182  gcFIXUP2(t->proc_attr, gc);
183  gcFIXUP2(t->guard, gc);
184  gcFIXUP2(t->immutables, gc);
185
186# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
187  return 0;
188# else
189  return
190  gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
191		    + ((t->name_pos + 1 - mzFLEX_DELTA)
192                       * sizeof(Scheme_Struct_Type *))));
193# endif
194#endif
195}
196
197#define mark_struct_type_val_IS_ATOMIC 0
198#define mark_struct_type_val_IS_CONST_SIZE 0
199
200
201static int mark_struct_property_SIZE(void *p, struct NewGC *gc) {
202#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
203  gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
204#else
205  return 0;
206#endif
207}
208
209static int mark_struct_property_MARK(void *p, struct NewGC *gc) {
210#ifndef GC_NO_MARK_PROCEDURE_NEEDED
211  Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
212  gcMARK2(i->name, gc);
213  gcMARK2(i->guard, gc);
214  gcMARK2(i->supers, gc);
215# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
216  return 0;
217# else
218  return
219  gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
220# endif
221#endif
222}
223
224static int mark_struct_property_FIXUP(void *p, struct NewGC *gc) {
225#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
226  Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
227  gcFIXUP2(i->name, gc);
228  gcFIXUP2(i->guard, gc);
229  gcFIXUP2(i->supers, gc);
230# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
231  return 0;
232# else
233  return
234  gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
235# endif
236#endif
237}
238
239#define mark_struct_property_IS_ATOMIC 0
240#define mark_struct_property_IS_CONST_SIZE 1
241
242
243static int mark_wrapped_evt_SIZE(void *p, struct NewGC *gc) {
244#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
245  gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
246#else
247  return 0;
248#endif
249}
250
251static int mark_wrapped_evt_MARK(void *p, struct NewGC *gc) {
252#ifndef GC_NO_MARK_PROCEDURE_NEEDED
253  Wrapped_Evt *ww = (Wrapped_Evt *)p;
254
255  gcMARK2(ww->evt, gc);
256  gcMARK2(ww->wrapper, gc);
257
258# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
259  return 0;
260# else
261  return
262  gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
263# endif
264#endif
265}
266
267static int mark_wrapped_evt_FIXUP(void *p, struct NewGC *gc) {
268#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
269  Wrapped_Evt *ww = (Wrapped_Evt *)p;
270
271  gcFIXUP2(ww->evt, gc);
272  gcFIXUP2(ww->wrapper, gc);
273
274# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
275  return 0;
276# else
277  return
278  gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
279# endif
280#endif
281}
282
283#define mark_wrapped_evt_IS_ATOMIC 0
284#define mark_wrapped_evt_IS_CONST_SIZE 1
285
286
287static int mark_nack_guard_evt_SIZE(void *p, struct NewGC *gc) {
288#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
289  gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
290#else
291  return 0;
292#endif
293}
294
295static int mark_nack_guard_evt_MARK(void *p, struct NewGC *gc) {
296#ifndef GC_NO_MARK_PROCEDURE_NEEDED
297  Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
298
299  gcMARK2(nw->maker, gc);
300
301# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
302  return 0;
303# else
304  return
305  gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
306# endif
307#endif
308}
309
310static int mark_nack_guard_evt_FIXUP(void *p, struct NewGC *gc) {
311#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
312  Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
313
314  gcFIXUP2(nw->maker, gc);
315
316# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
317  return 0;
318# else
319  return
320  gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
321# endif
322#endif
323}
324
325#define mark_nack_guard_evt_IS_ATOMIC 0
326#define mark_nack_guard_evt_IS_CONST_SIZE 1
327
328
329static int mark_active_replace_evt_SIZE(void *p, struct NewGC *gc) {
330#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
331  gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt));
332#else
333  return 0;
334#endif
335}
336
337static int mark_active_replace_evt_MARK(void *p, struct NewGC *gc) {
338#ifndef GC_NO_MARK_PROCEDURE_NEEDED
339  Active_Replace_Evt *a = (Active_Replace_Evt *)p;
340
341  gcMARK2(a->syncing, gc);
342  gcMARK2(a->wrapper, gc);
343  gcMARK2(a->orig, gc);
344
345# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
346  return 0;
347# else
348  return
349  gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt));
350# endif
351#endif
352}
353
354static int mark_active_replace_evt_FIXUP(void *p, struct NewGC *gc) {
355#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
356  Active_Replace_Evt *a = (Active_Replace_Evt *)p;
357
358  gcFIXUP2(a->syncing, gc);
359  gcFIXUP2(a->wrapper, gc);
360  gcFIXUP2(a->orig, gc);
361
362# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
363  return 0;
364# else
365  return
366  gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt));
367# endif
368#endif
369}
370
371#define mark_active_replace_evt_IS_ATOMIC 0
372#define mark_active_replace_evt_IS_CONST_SIZE 1
373
374
375static int mark_chaperone_SIZE(void *p, struct NewGC *gc) {
376#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
377  gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
378#else
379  return 0;
380#endif
381}
382
383static int mark_chaperone_MARK(void *p, struct NewGC *gc) {
384#ifndef GC_NO_MARK_PROCEDURE_NEEDED
385  Scheme_Chaperone *px = (Scheme_Chaperone *)p;
386
387  gcMARK2(px->val, gc);
388  gcMARK2(px->prev, gc);
389  gcMARK2(px->props, gc);
390  gcMARK2(px->redirects, gc);
391
392# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
393  return 0;
394# else
395  return
396  gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
397# endif
398#endif
399}
400
401static int mark_chaperone_FIXUP(void *p, struct NewGC *gc) {
402#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
403  Scheme_Chaperone *px = (Scheme_Chaperone *)p;
404
405  gcFIXUP2(px->val, gc);
406  gcFIXUP2(px->prev, gc);
407  gcFIXUP2(px->props, gc);
408  gcFIXUP2(px->redirects, gc);
409
410# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
411  return 0;
412# else
413  return
414  gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
415# endif
416#endif
417}
418
419#define mark_chaperone_IS_ATOMIC 0
420#define mark_chaperone_IS_CONST_SIZE 1
421
422
423