suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove "array of tagged" GC support

Browse Source 
The GC supported allocation for an array of objects where
the first one provides a tag, but at this point it was
used only in some corners. Change those corner and simplify
the GC by removing support for arrays of tagged objects.

The main corner to clean up is in the handling of a macro-expansion
observer and inferred names. Move those into the compile-time
environment. It's possible that name inference has been
broken by the changes, but in addition to passing the tests,
the generated bytecode for the base collections is exactly the
same as before the change.
This commit is contained in:
Matthew Flatt 2015-09-14 10:19:59 -06:00
parent bcd3d814fd
commit 28047789a9
47 changed files with 3222 additions and 786 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pkgs/racket-test-core/tests/racket/name.rktl
View File

@ -65,6 +65,9 @@
(test 'w object-name (let ([w (let ([x 5]) (lambda () x))]) w))
(test 'z object-name (let ([z (let ([x 5]) (cons 1 2) (lambda () x))]) z))
(test 'w object-name (let ([w (let () (lambda () 'x))]) w))
(test 'z object-name (let ([z (let () (cons 1 2) (lambda () 'x))]) z))
(set! f (lambda () 10))
(test 'f object-name f)

8
racket/src/racket/gc2/README
View File

@ -95,14 +95,6 @@ Racket allocates the following kinds of memory objects:
* Array - The allocated object is an array of pointers to other
allocated objects.
* Tagged Array - The allocated object is an array of tagged
objects. Every tagged object in the array is the same size and has
the same effective tag. After allocating the memory, Racket sets
the tag on the initial array element, but might not set the tag of
other elements until later. (Even if tags are not set for all
objects, the mark and fixup operations might be applied to all of
them.)
* Pair - specialization of Tagged to pairs.
* Interior Array - Like array objects, but pointers to the object can

8
racket/src/racket/gc2/gc2.h
View File

@ -204,12 +204,6 @@ GC2_EXTERN void *GC_malloc_pair(void *car, void *cdr);
The main potential advantage is that `car' and `cdr' don't
have to be retained by the callee in the case of a GC. */
GC2_EXTERN void *GC_malloc_array_tagged(size_t);
/*
Alloc an array of tagged items. Racket sets the tag in the first
item before a collection, by maybe not all items. When traversing,
use the first one for size. */
GC2_EXTERN void *GC_malloc_atomic(size_t size_in_bytes);
/*
Alloc pointerless memory (not necessarily zeroed). */
@ -605,6 +599,8 @@ GC2_EXTERN void GC_set_backpointer_object(void *p);
#define gcBYTES_TO_WORDS(x) ((x + (1 << gcLOG_WORD_SIZE) - 1) >> gcLOG_WORD_SIZE)
#define gcWORDS_TO_BYTES(x) (x << gcLOG_WORD_SIZE)
#define GC_NO_SIZE_NEEDED_FROM_PROCS 1
#define GC_INTERIORABLES_NEVER_MOVE 1
#endif /* __mzscheme_gc_2__ */

65
racket/src/racket/gc2/newgc.c
View File

@ -80,11 +80,10 @@ enum {
PAGE_TAGGED = 0,
PAGE_ATOMIC = 1,
PAGE_ARRAY = 2,
PAGE_TARRAY = 3,
PAGE_PAIR = 4,
PAGE_BIG = 5,
PAGE_PAIR = 3,
PAGE_BIG = 4,
/* the number of page types: */
PAGE_TYPES = 6
PAGE_TYPES = 5
};
enum {
@ -128,7 +127,6 @@ static const char *type_name[PAGE_TYPES] = {
"tagged",
"atomic",
"array",
"tagged array",
"pair",
"big"
};
@ -699,9 +697,6 @@ static void dump_page_map(NewGC *gc, const char *when)
case PAGE_ARRAY:
kind = 'r';
break;
case PAGE_TARRAY:
kind = 'y';
break;
case PAGE_PAIR:
kind = 'p';
break;
@ -1590,7 +1585,6 @@ void *GC_malloc_pair(void *car, void *cdr)
/* the allocation mechanism we present to the outside world */
void *GC_malloc(size_t s) { return allocate(s, PAGE_ARRAY); }
void *GC_malloc_one_tagged(size_t s) { return allocate(s, PAGE_TAGGED); }
void *GC_malloc_array_tagged(size_t s) { return allocate(s, PAGE_TARRAY); }
void *GC_malloc_atomic(size_t s) { return allocate(s, PAGE_ATOMIC); }
void *GC_malloc_atomic_uncollectable(size_t s) { return ofm_malloc_zero(s); }
void *GC_malloc_allow_interior(size_t s) { return allocate_medium(s, PAGE_ARRAY); }
@ -3748,17 +3742,6 @@ static inline void propagate_marks_worker(NewGC *gc, void *pp)
{
while(start < end) gcMARK2(*start++, gc); break;
}
case PAGE_TARRAY:
{
const unsigned short tag = *(unsigned short *)start;
ASSERT_TAG(tag);
end -= INSET_WORDS;
while(start < end) {
GC_ASSERT(gc->mark_table[tag]);
start += gc->mark_table[tag](start, gc);
}
break;
}
case PAGE_PAIR:
{
Scheme_Object *p = (Scheme_Object *)start;
@ -3897,7 +3880,6 @@ static void *trace_pointer_start(mpage *page, void *p) {
}
# define TRACE_PAGE_TAGGED PAGE_TAGGED
# define TRACE_PAGE_ARRAY PAGE_ARRAY
# define TRACE_PAGE_TAGGED_ARRAY PAGE_TARRAY
# define TRACE_PAGE_ATOMIC PAGE_ATOMIC
# define TRACE_PAGE_PAIR PAGE_PAIR
# define TRACE_PAGE_MALLOCFREE PAGE_TYPES
@ -3910,7 +3892,6 @@ const char *trace_source_kind(int kind)
case PAGE_TAGGED: return "_TAGGED";
case PAGE_ATOMIC: return "_ATOMIC";
case PAGE_ARRAY: return "_ARRAY";
case PAGE_TARRAY: return "_TARRAY";
case PAGE_PAIR: return "_PAIR";
case PAGE_BIG: return "_BIG";
case BT_STACK: return "STACK";
@ -4460,18 +4441,6 @@ static int repair_mixed_page(NewGC *gc, mpage *page, void **end)
case PAGE_ATOMIC:
start += info->size;
break;
case PAGE_TARRAY:
{
void **tempstart, **tempend = PPTR(info) + (info->size - INSET_WORDS);
unsigned short tag;
tempstart = OBJHEAD_TO_OBJPTR(start);
tag = *(unsigned short*)tempstart;
ASSERT_TAG(tag);
while (tempstart < tempend)
tempstart += fixup_table[tag](tempstart, gc);
start += info->size;
}
break;
case PAGE_PAIR:
{
Scheme_Object *p = (Scheme_Object *)OBJHEAD_TO_OBJPTR(start);
@ -4625,14 +4594,6 @@ static void repair_heap(NewGC *gc)
gcFIXUP2(SCHEME_CDR(p), gc);
}
break;
case PAGE_TARRAY:
{
unsigned short tag = *(unsigned short *)start;
ASSERT_TAG(tag);
end -= INSET_WORDS;
while(start < end) start += fixup_table[tag](start, gc);
break;
}
}
memory_in_use += page->size;
@ -4683,26 +4644,6 @@ static void repair_heap(NewGC *gc)
}
}
break;
case PAGE_TARRAY:
while(start < end) {
objhead *info = (objhead *)start;
size_t size = info->size;
if(info->mark) {
void **tempend = PPTR(info) + (info->size - INSET_WORDS);
unsigned short tag;
start = OBJHEAD_TO_OBJPTR(start);
tag = *(unsigned short*)start;
ASSERT_TAG(tag);
while(start < tempend)
start += fixup_table[tag](start, gc);
info->mark = 0;
start = PPTR(info) + size;
} else {
info->dead = 1;
start += size;
}
}
break;
case PAGE_PAIR:
while(start < end) {
objhead *info = (objhead *)start;

1
racket/src/racket/include/mzwin3m.def
View File

@ -204,7 +204,6 @@ EXPORTS
GC_malloc_one_tagged
GC_malloc_atomic_uncollectable
scheme_malloc_uncollectable
GC_malloc_array_tagged
GC_malloc_allow_interior
GC_malloc_atomic_allow_interior
GC_malloc_tagged_allow_interior

1
racket/src/racket/include/racket3m.exp
View File

@ -211,7 +211,6 @@ GC_malloc_atomic
GC_malloc_one_tagged
GC_malloc_atomic_uncollectable
scheme_malloc_uncollectable
GC_malloc_array_tagged
GC_malloc_allow_interior
GC_malloc_atomic_allow_interior
GC_malloc_tagged_allow_interior

3
racket/src/racket/include/scheme.h
View File

@ -1221,9 +1221,6 @@ typedef struct Scheme_Thread {
short suspend_break;
short external_break;
Scheme_Simple_Object *list_stack;
int list_stack_pos;
/* Racket client can use: */
void (*on_kill)(struct Scheme_Thread *p);
void *kill_data;

18
racket/src/racket/src/compenv.c
View File

@ -98,15 +98,9 @@ void scheme_init_compile_recs(Scheme_Compile_Info *src, int drec,
int i;
for (i = 0; i < n; i++) {
#ifdef MZTAG_REQUIRED
dest[i].type = scheme_rt_compile_info;
#endif
dest[i].comp = 1;
dest[i].dont_mark_local_use = src[drec].dont_mark_local_use;
dest[i].resolve_module_ids = src[drec].resolve_module_ids;
dest[i].value_name = scheme_false;
/* should be always NULL */
dest[i].observer = src[drec].observer;
dest[i].pre_unwrapped = 0;
dest[i].testing_constantness = 0;
dest[i].env_already = 0;
@ -120,13 +114,8 @@ void scheme_init_expand_recs(Scheme_Expand_Info *src, int drec,
int i;
for (i = 0; i < n; i++) {
#ifdef MZTAG_REQUIRED
dest[i].type = scheme_rt_compile_info;
#endif
dest[i].comp = 0;
dest[i].depth = src[drec].depth;
dest[i].value_name = scheme_false;
dest[i].observer = src[drec].observer;
dest[i].pre_unwrapped = 0;
dest[i].substitute_bindings = src[drec].substitute_bindings;
dest[i].testing_constantness = 0;
@ -144,15 +133,10 @@ void scheme_merge_compile_recs(Scheme_Compile_Info *src, int drec,
void scheme_init_lambda_rec(Scheme_Compile_Info *src, int drec,
Scheme_Compile_Info *lam, int dlrec)
{
#ifdef MZTAG_REQUIRED
lam[dlrec].type = scheme_rt_compile_info;
#endif
lam[dlrec].comp = 1;
lam[dlrec].dont_mark_local_use = src[drec].dont_mark_local_use;
lam[dlrec].resolve_module_ids = src[drec].resolve_module_ids;
lam[dlrec].substitute_bindings = src[dlrec].substitute_bindings;
lam[dlrec].value_name = scheme_false;
lam[dlrec].observer = src[drec].observer;
lam[dlrec].pre_unwrapped = 0;
lam[dlrec].testing_constantness = 0;
lam[dlrec].env_already = 0;
@ -166,7 +150,6 @@ void scheme_merge_lambda_rec(Scheme_Compile_Info *src, int drec,
void scheme_compile_rec_done_local(Scheme_Compile_Info *rec, int drec)
{
rec[drec].value_name = scheme_false;
}
/**********************************************************************/
@ -285,6 +268,7 @@ Scheme_Comp_Env *scheme_new_compilation_frame(int num_bindings, int flags, Schem
frame->insp = base->insp;
frame->prefix = base->prefix;
frame->in_modidx = base->in_modidx;
frame->observer = base->observer;
if (base->next)
frame->skip_depth = base->skip_depth + 1;

520
racket/src/racket/src/compile.c
View File

File diff suppressed because it is too large Load Diff

26
racket/src/racket/src/eval.c
View File

@ -4150,8 +4150,6 @@ static void *compile_k(void)
rec.dont_mark_local_use = 0;
rec.resolve_module_ids = !writeable && !genv->module;
rec.substitute_bindings = 1;
rec.value_name = scheme_false;
rec.observer = NULL;
rec.pre_unwrapped = 0;
rec.env_already = 0;
rec.comp_flags = comp_flags;
@ -4652,6 +4650,8 @@ static void *expand_k(void)
observer = scheme_get_expand_observe();
SCHEME_EXPAND_OBSERVE_START_EXPAND(observer);
env->observer = observer;
comp_flags = get_comp_flags(NULL);
if (as_local < 0) {
@ -4668,8 +4668,6 @@ static void *expand_k(void)
while (1) {
erec1.comp = 0;
erec1.depth = ((depth == -3) ? -2 : depth);
erec1.value_name = scheme_false;
erec1.observer = observer;
erec1.pre_unwrapped = 0;
erec1.env_already = 0;
erec1.comp_flags = comp_flags;
@ -4709,13 +4707,13 @@ static void *expand_k(void)
obj = scheme_add_lifts_as_let(obj, l, env, scheme_false, 0);
else
obj = add_lifts_as_begin(obj, l, env);
SCHEME_EXPAND_OBSERVE_LIFT_LOOP(erec1.observer,obj);
SCHEME_EXPAND_OBSERVE_LIFT_LOOP(env->observer, obj);
if ((depth >= 0) || as_local)
break;
} else {
if (as_local > 0) {
obj = add_lifts_as_begin(obj, scheme_null, env);
SCHEME_EXPAND_OBSERVE_LIFT_LOOP(erec1.observer,obj);
SCHEME_EXPAND_OBSERVE_LIFT_LOOP(env->observer,obj);
}
break;
}
@ -5301,6 +5299,8 @@ do_local_expand(const char *name, int for_stx, int catch_lifts, int for_expr, in
}
}
env->observer = observer;
if (local_scope) {
/* Since we have an expression from local context,
we need to remove the temporary scope... */
@ -5336,15 +5336,16 @@ do_local_expand(const char *name, int for_stx, int catch_lifts, int for_expr, in
}
memset(drec, 0, sizeof(drec));
drec[0].value_name = scheme_false; /* or scheme_current_thread->current_local_name ? */
drec[0].depth = -2;
drec[0].observer = observer;
{
int comp_flags;
comp_flags = get_comp_flags(NULL);
drec[0].comp_flags = comp_flags;
}
if (!(env->flags & (SCHEME_TOPLEVEL_FRAME | SCHEME_MODULE_FRAME | SCHEME_MODULE_BEGIN_FRAME)))
env->value_name = scheme_current_thread->current_local_name;
xl = scheme_check_immediate_macro(l, env, drec, 0, &gval, 1);
if (SAME_OBJ(xl, l) && !for_expr) {
@ -5830,6 +5831,7 @@ local_eval(int argc, Scheme_Object **argv)
stx_env = scheme_new_compilation_frame(0, SCHEME_FOR_INTDEF | SCHEME_USE_SCOPES_TO_NEXT, rib, stx_env);
scheme_add_local_syntax(cnt, stx_env);
env->observer = observer;
/* Scope names */
if (scheme_current_thread->current_local_scope)
@ -5852,8 +5854,6 @@ local_eval(int argc, Scheme_Object **argv)
Scheme_Compile_Expand_Info rec;
rec.comp = 0;
rec.depth = -1;
rec.value_name = scheme_false;
rec.observer = observer;
rec.pre_unwrapped = 0;
rec.env_already = 0;
rec.substitute_bindings = 1;
@ -5872,7 +5872,8 @@ local_eval(int argc, Scheme_Object **argv)
scheme_make_pair(rib, scheme_env_phase(stx_env->genv)));
rn_names = scheme_named_map_1(NULL, revert_expr_scopes, rn_names, (Scheme_Object *)init_env);
scheme_bind_syntaxes("local syntax definition", rn_names, expr,
stx_env->genv->exp_env, stx_env->insp, &rec, 0,
stx_env->genv->exp_env, stx_env->insp,
&rec, 0, stx_env->observer,
stx_env, stx_env,
&pos, rib, 1);
}
@ -6097,7 +6098,7 @@ static void mark_pruned_prefixes(struct NewGC *gc) XFORM_SKIP_PROC
GC_set_backpointer_object(pf->backpointer);
#endif
GC_mark_no_recur(gc, 1);
gcMARK(pf);
gcMARK2(pf, gc);
pf = (Scheme_Prefix *)GC_resolve2(pf, gc);
GC_retract_only_mark_stack_entry(pf, gc);
GC_mark_no_recur(gc, 0);
@ -6132,7 +6133,6 @@ START_XFORM_SKIP;
static void register_traversers(void)
{
GC_REG_TRAV(scheme_rt_compile_info, mark_comp_info);
GC_REG_TRAV(scheme_rt_saved_stack, mark_saved_stack);
}

4
racket/src/racket/src/fun.c
View File

@ -1953,7 +1953,7 @@ scheme_apply_macro(Scheme_Object *name, Scheme_Env *menv,
code = scheme_stx_taint_disarm(code, NULL);
pre_code = code;
SCHEME_EXPAND_OBSERVE_MACRO_PRE_X(rec[drec].observer, code);
SCHEME_EXPAND_OBSERVE_MACRO_PRE_X(env->observer, code);
{
Scheme_Dynamic_State dyn_state;
@ -1976,7 +1976,7 @@ scheme_apply_macro(Scheme_Object *name, Scheme_Env *menv,
scheme_pop_continuation_frame(&cframe);
}
SCHEME_EXPAND_OBSERVE_MACRO_POST_X(rec[drec].observer, code, pre_code);
SCHEME_EXPAND_OBSERVE_MACRO_POST_X(env->observer, code, pre_code);
if (!SCHEME_STXP(code)) {
scheme_raise_exn(MZEXN_FAIL_CONTRACT,

34
racket/src/racket/src/mkmark.rkt
View File

@ -31,19 +31,23 @@
[(regexp-match re:close l)
(error 'mkmark.rkt "unexpected close")]
[else (cons l (loop))])))))]
[print-lines (lambda (l [skip-rx #f])
[print-lines (lambda (l [skip-rx #f] [skip-alt-bracket #f])
(let loop ([l l] [skip? #f])
(cond
[(null? l) (void)]
[(and skip-rx (regexp-match? skip-rx (car l)))
(when skip-alt-bracket
(if skip?
(printf "#endif\n")
(printf "#ifdef ~a\n" skip-alt-bracket)))
(loop (cdr l) (not skip?))]
[skip?
[(and skip? (not skip-alt-bracket))
(loop (cdr l) #t)]
[(regexp-match? #rx"(START|END)_[A-Z_]+_ONLY;" (car l))
(loop (cdr l) skip?)]
[else
(printf "~a\n" (car l))
(loop (cdr l) #f)])))])
(loop (cdr l) skip?)])))])
(let ([prefix (read-lines re:mark)]
[mark (read-lines re:size-or-more)]
[fixup (if (regexp-match-peek re:fixup-start (current-input-port))
@ -52,13 +56,26 @@
(read-lines re:size))
null)]
[size (read-lines re:close)])
(define (print-size size)
(printf "# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS\n")
(printf " return 0;\n")
(printf "# else\n")
(printf " return\n")
(print-lines size)
(printf "# endif\n"))
(printf "static int ~a_SIZE(void *p, struct NewGC *gc) {\n" name)
(printf "#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS\n")
(print-lines prefix)
(printf " return\n")
(print-lines size)
(printf "#else\n")
(printf " return 0;\n")
(printf "#endif\n")
(printf "}\n\n")
(printf "static int ~a_MARK(void *p, struct NewGC *gc) {\n" name)
(printf "#ifndef GC_NO_MARK_PROCEDURE_NEEDED\n")
(print-lines prefix)
(print-lines (map (lambda (s)
(regexp-replace*
@ -70,11 +87,12 @@
""))
mark)
#rx"FIXUP_ONLY")
(printf " return\n")
(print-lines size)
(print-size size)
(printf "#endif\n")
(printf "}\n\n")
(printf "static int ~a_FIXUP(void *p, struct NewGC *gc) {\n" name)
(printf "#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED\n")
(print-lines prefix)
(print-lines (map (lambda (s)
(regexp-replace*
@ -88,8 +106,8 @@
mark
fixup))
#rx"MARK_ONLY")
(printf " return\n")
(print-lines size)
(print-size size)
(printf "#endif\n")
(printf "}\n\n")
(printf "#define ~a_IS_ATOMIC ~a\n"

65
racket/src/racket/src/module.c
View File

@ -7041,7 +7041,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
LOG_EXPAND_DECLS;
if (!rec[drec].comp) {
SCHEME_EXPAND_OBSERVE_PRIM_MODULE(rec[drec].observer);
SCHEME_EXPAND_OBSERVE_PRIM_MODULE(env->observer);
if (rec[drec].depth > 0)
rec[drec].depth++;
}
@ -7205,7 +7205,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
m->super_bxs_info = super_bxs_info;
}
SCHEME_EXPAND_OBSERVE_PREPARE_ENV(rec[drec].observer);
SCHEME_EXPAND_OBSERVE_PREPARE_ENV(env->observer);
/* load the module for the initial require */
if (iidx) {
@ -7291,6 +7291,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
else
benv = scheme_new_expand_env(menv, env->insp, frame_scopes,
SCHEME_MODULE_BEGIN_FRAME | SCHEME_KEEP_SCOPES_FRAME);
benv->observer = env->observer;
}
/* If fm isn't a single expression, it certainly needs a
@ -7308,7 +7309,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
fm = scheme_datum_to_syntax(fm, form, mb_ctx, 0, 2);
if (check_mb) {
SCHEME_EXPAND_OBSERVE_TAG(rec[drec].observer, fm);
SCHEME_EXPAND_OBSERVE_TAG(env->observer, fm);
}
fm = scheme_stx_property(fm, module_name_symbol, scheme_resolved_module_path_value(rmp));
@ -7321,7 +7322,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
fm = scheme_stx_add_module_frame_context(fm, rn_set);
SCHEME_EXPAND_OBSERVE_RENAME_ONE(rec[drec].observer, fm);
SCHEME_EXPAND_OBSERVE_RENAME_ONE(env->observer, fm);
if (!check_mb) {
fm = scheme_check_immediate_macro(fm, benv, rec, drec, &mbval, 1);
@ -7334,7 +7335,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
fm = scheme_datum_to_syntax(fm, form, mb_ctx, 0, 2);
fm = scheme_stx_property(fm, module_name_symbol, scheme_resolved_module_path_value(rmp));
SCHEME_EXPAND_OBSERVE_TAG(rec[drec].observer, fm);
SCHEME_EXPAND_OBSERVE_TAG(env->observer, fm);
check_mb = 1;
}
@ -7451,7 +7452,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env,
LOG_END_EXPAND(m);
SCHEME_EXPAND_OBSERVE_RENAME_ONE(rec[drec].observer, fm);
SCHEME_EXPAND_OBSERVE_RENAME_ONE(env->observer, fm);
return fm;
}
@ -8178,7 +8179,7 @@ static Scheme_Object *do_module_begin(Scheme_Object *orig_form, Scheme_Comp_Env
scoped identifiers for definitions. */
form = introduce_to_module_context(form, rn_set);
observer = rec[drec].observer;
observer = env->observer;
SCHEME_EXPAND_OBSERVE_RENAME_ONE(observer, form);
_num_phases = MALLOC_ONE_ATOMIC(int);
@ -8226,8 +8227,6 @@ static Scheme_Object *do_module_begin(Scheme_Object *orig_form, Scheme_Comp_Env
crec.dont_mark_local_use = 0;
crec.resolve_module_ids = 0;
crec.substitute_bindings = 1;
crec.value_name = scheme_false;
crec.observer = NULL;
crec.pre_unwrapped = 0;
crec.env_already = 0;
crec.comp_flags = rec[drec].comp_flags;
@ -8692,20 +8691,14 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
void **args;
if (rec) {
recx = MALLOC_ONE_RT(Scheme_Compile_Expand_Info);
recx = MALLOC_ONE_ATOMIC(Scheme_Compile_Expand_Info);
memcpy(recx, rec + drec, sizeof(Scheme_Compile_Expand_Info));
#ifdef MZTAG_REQUIRED
recx->type = scheme_rt_compile_info;
#endif
} else
recx = NULL;
if (erec) {
erecx = MALLOC_ONE_RT(Scheme_Compile_Expand_Info);
erecx = MALLOC_ONE_ATOMIC(Scheme_Compile_Expand_Info);
memcpy(erecx, erec + derec, sizeof(Scheme_Compile_Expand_Info));
#ifdef MZTAG_REQUIRED
erecx->type = scheme_rt_compile_info;
#endif
} else
erecx = NULL;
@ -8813,11 +8806,8 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
/* For syntax-local-context, etc., in a d-s RHS: */
rhs_env = scheme_new_comp_env(env->genv, env->insp, NULL, SCHEME_TOPLEVEL_FRAME);
if (erec) {
observer = erec[derec].observer;
} else {
observer = NULL;
}
observer = env->observer;
rhs_env->observer = observer;
maybe_has_lifts = 0;
lift_ctx = scheme_generate_lifts_key();
@ -8864,8 +8854,6 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
Scheme_Expand_Info erec1;
erec1.comp = 0;
erec1.depth = -1;
erec1.value_name = scheme_false;
erec1.observer = observer;
erec1.pre_unwrapped = 0;
erec1.substitute_bindings = 1;
erec1.env_already = 0;
@ -9107,8 +9095,6 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
mrec.dont_mark_local_use = 0;
mrec.resolve_module_ids = 0;
mrec.substitute_bindings = 1;
mrec.value_name = NULL;
mrec.observer = NULL;
mrec.pre_unwrapped = 0;
mrec.env_already = 0;
mrec.comp_flags = rec[drec].comp_flags;
@ -9116,8 +9102,6 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
if (erec) {
erec1.comp = 0;
erec1.depth = -1;
erec1.value_name = boundname;
erec1.observer = observer;
erec1.pre_unwrapped = 0;
erec1.substitute_bindings = 1;
erec1.env_already = 0;
@ -9151,9 +9135,14 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
} else {
if (erec) {
SCHEME_EXPAND_OBSERVE_PHASE_UP(observer);
eenv->value_name = boundname;
eenv->observer = xenv->observer;
code = scheme_expand_expr_lift_to_let(code, eenv, &erec1, 0);
}
eenv->value_name = boundname;
eenv->observer = NULL;
m = scheme_compile_expr_lift_to_let(code, eenv, &mrec, 0);
eenv->value_name = NULL;
}
if (!for_stx) {
@ -9370,6 +9359,7 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
frame_scopes = scheme_module_context_frame_scopes(rn_set, xenv->scopes);
cenv = scheme_new_comp_env(env->genv, env->insp, frame_scopes,
SCHEME_TOPLEVEL_FRAME | SCHEME_KEEP_SCOPES_FRAME);
cenv->observer = env->observer;
}
lift_data = scheme_make_vector(3, NULL);
@ -9435,7 +9425,6 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
if (erec) {
Scheme_Expand_Info erec1;
scheme_init_expand_recs(erec, derec, &erec1, 1);
erec1.value_name = scheme_false;
e = scheme_expand_expr(e, nenv, &erec1, 0);
expanded_l = scheme_make_pair(e, expanded_l);
}
@ -9444,7 +9433,9 @@ static Scheme_Object *do_module_begin_at_phase(Scheme_Object *form, Scheme_Comp_
Scheme_Compile_Info crec1;
scheme_init_compile_recs(rec, drec, &crec1, 1);
crec1.resolve_module_ids = 0;
nenv->observer = NULL;
e = scheme_compile_expr(e, nenv, &crec1, 0);
nenv->observer = env->observer;
}
lifted_reqs = scheme_frame_get_require_lifts(cenv);
@ -9657,7 +9648,7 @@ static Scheme_Object *expand_all_provides(Scheme_Object *form,
Scheme_Object *e, *ex, *fst;
Scheme_Comp_Env *pcenv;
observer = rec[drec].observer;
observer = cenv->observer;
saved_provides = scheme_reverse(bxs->saved_provides);
while (!SCHEME_NULLP(saved_provides)) {
@ -9684,6 +9675,7 @@ static Scheme_Object *expand_all_provides(Scheme_Object *form,
pcenv = scheme_new_comp_env(penv, penv->access_insp, NULL, SCHEME_TOPLEVEL_FRAME);
else
pcenv = scheme_new_expand_env(penv, penv->access_insp, NULL, SCHEME_TOPLEVEL_FRAME);
pcenv->observer = cenv->observer;
} else {
pcenv = cenv;
}
@ -9728,10 +9720,10 @@ static Scheme_Object *expand_submodules(Scheme_Compile_Expand_Info *rec, int dre
while (!SCHEME_NULLP(l)) {
mod = SCHEME_CAR(l);
SCHEME_EXPAND_OBSERVE_ENTER_PRIM(rec[drec].observer,SCHEME_CAR(mod));
SCHEME_EXPAND_OBSERVE_ENTER_PRIM(env->observer, SCHEME_CAR(mod));
mod = do_module(SCHEME_CAR(mod), env, rec, drec, ancestry, env->genv->module->submodule_path, post,
bxs, SCHEME_CDR(mod));
SCHEME_EXPAND_OBSERVE_EXIT_PRIM(rec[drec].observer,mod);
SCHEME_EXPAND_OBSERVE_EXIT_PRIM(env->observer,mod);
mods = scheme_make_pair(mod, mods);
@ -9951,7 +9943,7 @@ module_begin_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_In
static Scheme_Object *
module_begin_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec)
{
SCHEME_EXPAND_OBSERVE_PRIM_MODULE_BEGIN(erec[drec].observer);
SCHEME_EXPAND_OBSERVE_PRIM_MODULE_BEGIN(env->observer);
return do_module_begin(form, env, erec, drec);
}
@ -10846,7 +10838,6 @@ static Scheme_Object *expand_provide(Scheme_Object *e, int at_phase,
stop, xenv, 0);
scheme_init_expand_recs(rec, drec, &erec1, 1);
erec1.value_name = scheme_false;
erec1.depth = -1;
p = scheme_current_thread;
@ -12597,7 +12588,7 @@ require_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *r
static Scheme_Object *
require_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec)
{
SCHEME_EXPAND_OBSERVE_PRIM_REQUIRE(erec[drec].observer);
SCHEME_EXPAND_OBSERVE_PRIM_REQUIRE(env->observer);
return do_require(form, env, erec, drec);
}
@ -12631,7 +12622,7 @@ provide_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *r
static Scheme_Object *
provide_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec)
{
SCHEME_EXPAND_OBSERVE_PRIM_PROVIDE(erec[drec].observer);
SCHEME_EXPAND_OBSERVE_PRIM_PROVIDE(env->observer);
scheme_wrong_syntax(NULL, NULL, form, "not in module body");
return NULL;
}
@ -12646,7 +12637,7 @@ declare_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *r
static Scheme_Object *
declare_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec)
{
SCHEME_EXPAND_OBSERVE_PRIM_PROVIDE(erec[drec].observer);
SCHEME_EXPAND_OBSERVE_PRIM_PROVIDE(env->observer);
scheme_wrong_syntax(NULL, NULL, form, "not in module body");
return NULL;
}

21
racket/src/racket/src/mzmark_compenv.inc
View File

@ -1,11 +1,15 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_comp_env_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Comp_Env));
#else
return 0;
#endif
}
static int mark_comp_env_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Comp_Env *e = (Scheme_Comp_Env *)p;
gcMARK2(e->genv, gc);
@ -13,6 +17,8 @@ static int mark_comp_env_MARK(void *p, struct NewGC *gc) {
gcMARK2(e->prefix, gc);
gcMARK2(e->next, gc);
gcMARK2(e->scopes, gc);
gcMARK2(e->value_name, gc);
gcMARK2(e->observer, gc);
gcMARK2(e->binders, gc);
gcMARK2(e->bindings, gc);
gcMARK2(e->vals, gc);
@ -30,11 +36,17 @@ static int mark_comp_env_MARK(void *p, struct NewGC *gc) {
gcMARK2(e->expand_result_adjust_arg, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Comp_Env));
# endif
#endif
}
static int mark_comp_env_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Comp_Env *e = (Scheme_Comp_Env *)p;
gcFIXUP2(e->genv, gc);
@ -42,6 +54,8 @@ static int mark_comp_env_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(e->prefix, gc);
gcFIXUP2(e->next, gc);
gcFIXUP2(e->scopes, gc);
gcFIXUP2(e->value_name, gc);
gcFIXUP2(e->observer, gc);
gcFIXUP2(e->binders, gc);
gcFIXUP2(e->bindings, gc);
gcFIXUP2(e->vals, gc);
@ -59,8 +73,13 @@ static int mark_comp_env_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(e->expand_result_adjust_arg, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Comp_Env));
# endif
#endif
}
#define mark_comp_env_IS_ATOMIC 0

46
racket/src/racket/src/mzmark_eval.inc
View File

@ -1,57 +1,43 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_comp_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
}
static int mark_comp_info_MARK(void *p, struct NewGC *gc) {
Scheme_Compile_Info *i = (Scheme_Compile_Info *)p;
gcMARK2(i->value_name, gc);
gcMARK2(i->observer, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
}
static int mark_comp_info_FIXUP(void *p, struct NewGC *gc) {
Scheme_Compile_Info *i = (Scheme_Compile_Info *)p;
gcFIXUP2(i->value_name, gc);
gcFIXUP2(i->observer, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
}
#define mark_comp_info_IS_ATOMIC 0
#define mark_comp_info_IS_CONST_SIZE 1
static int mark_saved_stack_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
#else
return 0;
#endif
}
static int mark_saved_stack_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
gcMARK2(saved->prev, gc);
gcMARK2(saved->runstack_start, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
# endif
#endif
}
static int mark_saved_stack_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
gcFIXUP2(saved->prev, gc);
gcFIXUP2(saved->runstack_start, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
# endif
#endif
}
#define mark_saved_stack_IS_ATOMIC 0

85
racket/src/racket/src/mzmark_fun.inc
View File

@ -1,30 +1,45 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_closure_info_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Closure_Info));
#else
return 0;
#endif
}
static int mark_closure_info_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Closure_Info *i = (Closure_Info *)p;
gcMARK2(i->local_flags, gc);
gcMARK2(i->base_closure_map, gc);
gcMARK2(i->local_type_map, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Closure_Info));
# endif
#endif
}
static int mark_closure_info_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Closure_Info *i = (Closure_Info *)p;
gcFIXUP2(i->local_flags, gc);
gcFIXUP2(i->base_closure_map, gc);
gcFIXUP2(i->local_type_map, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Closure_Info));
# endif
#endif
}
#define mark_closure_info_IS_ATOMIC 0
@ -32,28 +47,43 @@ static int mark_closure_info_FIXUP(void *p, struct NewGC *gc) {
static int mark_dyn_wind_cell_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
#else
return 0;
#endif
}
static int mark_dyn_wind_cell_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
gcMARK2(l->dw, gc);
gcMARK2(l->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
# endif
#endif
}
static int mark_dyn_wind_cell_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
gcFIXUP2(l->dw, gc);
gcFIXUP2(l->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
# endif
#endif
}
#define mark_dyn_wind_cell_IS_ATOMIC 0
@ -61,30 +91,45 @@ static int mark_dyn_wind_cell_FIXUP(void *p, struct NewGC *gc) {
static int mark_dyn_wind_info_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
#else
return 0;
#endif
}
static int mark_dyn_wind_info_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Dyn_Wind *d = (Dyn_Wind *)p;
gcMARK2(d->pre, gc);
gcMARK2(d->act, gc);
gcMARK2(d->post, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
# endif
#endif
}
static int mark_dyn_wind_info_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Dyn_Wind *d = (Dyn_Wind *)p;
gcFIXUP2(d->pre, gc);
gcFIXUP2(d->act, gc);
gcFIXUP2(d->post, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
# endif
#endif
}
#define mark_dyn_wind_info_IS_ATOMIC 0
@ -92,30 +137,45 @@ static int mark_dyn_wind_info_FIXUP(void *p, struct NewGC *gc) {
static int mark_cont_mark_chain_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
#else
return 0;
#endif
}
static int mark_cont_mark_chain_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
gcMARK2(c->key, gc);
gcMARK2(c->val, gc);
gcMARK2(c->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
# endif
#endif
}
static int mark_cont_mark_chain_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
gcFIXUP2(c->key, gc);
gcFIXUP2(c->val, gc);
gcFIXUP2(c->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
# endif
#endif
}
#define mark_cont_mark_chain_IS_ATOMIC 0
@ -125,11 +185,15 @@ static int mark_cont_mark_chain_FIXUP(void *p, struct NewGC *gc) {
#ifdef MZ_USE_JIT
static int mark_lightweight_cont_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation));
#else
return 0;
#endif
}
static int mark_lightweight_cont_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Lightweight_Continuation *lw = (Scheme_Lightweight_Continuation *)p;
gcMARK2(lw->saved_lwc, gc);
@ -137,11 +201,17 @@ static int mark_lightweight_cont_MARK(void *p, struct NewGC *gc) {
gcMARK2(lw->runstack_slice, gc);
gcMARK2(lw->cont_mark_stack_slice, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation));
# endif
#endif
}
static int mark_lightweight_cont_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Lightweight_Continuation *lw = (Scheme_Lightweight_Continuation *)p;
gcFIXUP2(lw->saved_lwc, gc);
@ -149,8 +219,13 @@ static int mark_lightweight_cont_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(lw->runstack_slice, gc);
gcFIXUP2(lw->cont_mark_stack_slice, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation));
# endif
#endif
}
#define mark_lightweight_cont_IS_ATOMIC 0

68
racket/src/racket/src/mzmark_future.inc
View File

@ -3,11 +3,15 @@
#ifdef MZ_USE_FUTURES
static int future_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(future_t));
#else
return 0;
#endif
}
static int future_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
future_t *f = (future_t *)p;
gcMARK2(f->orig_lambda, gc);
gcMARK2(f->cust, gc);
@ -37,11 +41,17 @@ static int future_MARK(void *p, struct NewGC *gc) {
gcMARK2(f->prev_in_fsema_queue, gc);
gcMARK2(f->next_in_fsema_queue, gc);
gcMARK2(f->touching, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(future_t));
# endif
#endif
}
static int future_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
future_t *f = (future_t *)p;
gcFIXUP2(f->orig_lambda, gc);
gcFIXUP2(f->cust, gc);
@ -71,8 +81,13 @@ static int future_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(f->prev_in_fsema_queue, gc);
gcFIXUP2(f->next_in_fsema_queue, gc);
gcFIXUP2(f->touching, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(future_t));
# endif
#endif
}
#define future_IS_ATOMIC 0
@ -80,24 +95,39 @@ static int future_FIXUP(void *p, struct NewGC *gc) {
static int fsemaphore_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
#else
return 0;
#endif
}
static int fsemaphore_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
fsemaphore_t *s = (fsemaphore_t*)p;
gcMARK2(s->queue_front, gc);
gcMARK2(s->queue_end, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
# endif
#endif
}
static int fsemaphore_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
fsemaphore_t *s = (fsemaphore_t*)p;
gcFIXUP2(s->queue_front, gc);
gcFIXUP2(s->queue_end, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
# endif
#endif
}
#define fsemaphore_IS_ATOMIC 0
@ -107,28 +137,43 @@ static int fsemaphore_FIXUP(void *p, struct NewGC *gc) {
#else
static int sequential_future_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(future_t));
#else
return 0;
#endif
}
static int sequential_future_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
future_t *f = (future_t *)p;
gcMARK2(f->orig_lambda, gc);
gcMARK2(f->running_sema, gc);
gcMARK2(f->retval, gc);
gcMARK2(f->multiple_array, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(future_t));
# endif
#endif
}
static int sequential_future_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
future_t *f = (future_t *)p;
gcFIXUP2(f->orig_lambda, gc);
gcFIXUP2(f->running_sema, gc);
gcFIXUP2(f->retval, gc);
gcFIXUP2(f->multiple_array, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(future_t));
# endif
#endif
}
#define sequential_future_IS_ATOMIC 0
@ -136,22 +181,37 @@ static int sequential_future_FIXUP(void *p, struct NewGC *gc) {
static int sequential_fsemaphore_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
#else
return 0;
#endif
}
static int sequential_fsemaphore_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
fsemaphore_t *s = (fsemaphore_t*)p;
gcMARK2(s->sema, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
# endif
#endif
}
static int sequential_fsemaphore_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
fsemaphore_t *s = (fsemaphore_t*)p;
gcFIXUP2(s->sema, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
# endif
#endif
}
#define sequential_fsemaphore_IS_ATOMIC 0

17
racket/src/racket/src/mzmark_hash.inc
View File

@ -1,13 +1,17 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int hash_tree_val_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
int popcount = hamt_popcount(ht->bitmap);
return
gcBYTES_TO_WORDS(HASH_TREE_RECORD_SIZE(SCHEME_HASHTR_KIND(ht), popcount));
#else
return 0;
#endif
}
static int hash_tree_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
int popcount = hamt_popcount(ht->bitmap);
int i;
@ -15,11 +19,17 @@ static int hash_tree_val_MARK(void *p, struct NewGC *gc) {
gcMARK2(ht->els[i], gc);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(HASH_TREE_RECORD_SIZE(SCHEME_HASHTR_KIND(ht), popcount));
# endif
#endif
}
static int hash_tree_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
int popcount = hamt_popcount(ht->bitmap);
int i;
@ -27,8 +37,13 @@ static int hash_tree_val_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(ht->els[i], gc);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(HASH_TREE_RECORD_SIZE(SCHEME_HASHTR_KIND(ht), popcount));
# endif
#endif
}
#define hash_tree_val_IS_ATOMIC 0

68
racket/src/racket/src/mzmark_jit.inc
View File

@ -1,6 +1,7 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int native_closure_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size;
@ -8,12 +9,15 @@ static int native_closure_SIZE(void *p, struct NewGC *gc) {
closure_size = -(closure_size + 1);
}
return
gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
+ (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *)));
#else
return 0;
#endif
}
static int native_closure_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size;
@ -37,12 +41,18 @@ static int native_closure_MARK(void *p, struct NewGC *gc) {
# undef CLOSURE_DATA_TYPE
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
+ (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *)));
# endif
#endif
}
static int native_closure_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size;
@ -61,9 +71,14 @@ static int native_closure_FIXUP(void *p, struct NewGC *gc) {
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
+ (closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *)));
# endif
#endif
}
#define native_closure_IS_ATOMIC 0
@ -71,11 +86,15 @@ static int native_closure_FIXUP(void *p, struct NewGC *gc) {
static int mark_jit_state_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(mz_jit_state));
#else
return 0;
#endif
}
static int mark_jit_state_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
mz_jit_state *j = (mz_jit_state *)p;
gcMARK2(j->mappings, gc);
gcMARK2(j->self_data, gc);
@ -84,11 +103,17 @@ static int mark_jit_state_MARK(void *p, struct NewGC *gc) {
gcMARK2(j->retaining_data, gc);
gcMARK2(j->patch_depth, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(mz_jit_state));
# endif
#endif
}
static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
mz_jit_state *j = (mz_jit_state *)p;
gcFIXUP2(j->mappings, gc);
gcFIXUP2(j->self_data, gc);
@ -97,8 +122,13 @@ static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(j->retaining_data, gc);
gcFIXUP2(j->patch_depth, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(mz_jit_state));
# endif
#endif
}
#define mark_jit_state_IS_ATOMIC 0
@ -106,11 +136,15 @@ static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) {
static int native_unclosed_proc_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
#else
return 0;
#endif
}
static int native_unclosed_proc_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
int i;
@ -125,11 +159,17 @@ static int native_unclosed_proc_MARK(void *p, struct NewGC *gc) {
}
gcMARK2(d->tl_map, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
# endif
#endif
}
static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
int i;
@ -144,8 +184,13 @@ static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) {
}
gcFIXUP2(d->tl_map, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
# endif
#endif
}
#define native_unclosed_proc_IS_ATOMIC 0
@ -153,28 +198,43 @@ static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) {
static int native_unclosed_proc_plus_case_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
#else
return 0;
#endif
}
static int native_unclosed_proc_plus_case_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p;
native_unclosed_proc_MARK(p, gc);
gcMARK2(d->case_lam, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
# endif
#endif
}
static int native_unclosed_proc_plus_case_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p;
native_unclosed_proc_FIXUP(p, gc);
gcFIXUP2(d->case_lam, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
# endif
#endif
}
#define native_unclosed_proc_plus_case_IS_ATOMIC 0

34
racket/src/racket/src/mzmark_letrec_check.inc
View File

@ -1,11 +1,15 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_letrec_check_frame_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Letrec_Check_Frame));
#else
return 0;
#endif
}
static int mark_letrec_check_frame_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Letrec_Check_Frame *frame = (Letrec_Check_Frame *)p;
gcMARK2(frame->def, gc);
@ -14,11 +18,17 @@ static int mark_letrec_check_frame_MARK(void *p, struct NewGC *gc) {
gcMARK2(frame->head, gc);
gcMARK2(frame->deferred_chain, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Letrec_Check_Frame));
# endif
#endif
}
static int mark_letrec_check_frame_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Letrec_Check_Frame *frame = (Letrec_Check_Frame *)p;
gcFIXUP2(frame->def, gc);
@ -27,8 +37,13 @@ static int mark_letrec_check_frame_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(frame->head, gc);
gcFIXUP2(frame->deferred_chain, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Letrec_Check_Frame));
# endif
#endif
}
#define mark_letrec_check_frame_IS_ATOMIC 0
@ -36,30 +51,45 @@ static int mark_letrec_check_frame_FIXUP(void *p, struct NewGC *gc) {
static int mark_scheme_deferred_expr_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Deferred_Expr));
#else
return 0;
#endif
}
static int mark_scheme_deferred_expr_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Deferred_Expr *clos = (Scheme_Deferred_Expr *)p;
gcMARK2(clos->expr, gc);
gcMARK2(clos->frame, gc);
gcMARK2(clos->chain_next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Deferred_Expr));
# endif
#endif
}
static int mark_scheme_deferred_expr_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Deferred_Expr *clos = (Scheme_Deferred_Expr *)p;
gcFIXUP2(clos->expr, gc);
gcFIXUP2(clos->frame, gc);
gcFIXUP2(clos->chain_next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Deferred_Expr));
# endif
#endif
}
#define mark_scheme_deferred_expr_IS_ATOMIC 0

68
racket/src/racket/src/mzmark_network.inc
View File

@ -2,13 +2,17 @@
#ifdef USE_TCP
static int mark_listener_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
listener_t *l = (listener_t *)p;
return
gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - mzFLEX_DELTA) * sizeof(tcp_t)));
#else
return 0;
#endif
}
static int mark_listener_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
listener_t *l = (listener_t *)p;
@ -17,11 +21,17 @@ static int mark_listener_MARK(void *p, struct NewGC *gc) {
gcMARK2(l->pfd, gc);
# endif
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - mzFLEX_DELTA) * sizeof(tcp_t)));
# endif
#endif
}
static int mark_listener_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
listener_t *l = (listener_t *)p;
@ -30,8 +40,13 @@ static int mark_listener_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(l->pfd, gc);
# endif
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - mzFLEX_DELTA) * sizeof(tcp_t)));
# endif
#endif
}
#define mark_listener_IS_ATOMIC 0
@ -39,28 +54,43 @@ static int mark_listener_FIXUP(void *p, struct NewGC *gc) {
static int mark_tcp_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
#else
return 0;
#endif
}
static int mark_tcp_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Tcp *tcp = (Scheme_Tcp *)p;
gcMARK2(tcp->b.buffer, gc);
gcMARK2(tcp->b.out_buffer, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
# endif
#endif
}
static int mark_tcp_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Tcp *tcp = (Scheme_Tcp *)p;
gcFIXUP2(tcp->b.buffer, gc);
gcFIXUP2(tcp->b.out_buffer, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
# endif
#endif
}
#define mark_tcp_IS_ATOMIC 0
@ -69,28 +99,43 @@ static int mark_tcp_FIXUP(void *p, struct NewGC *gc) {
# ifdef UDP_IS_SUPPORTED
static int mark_udp_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
#else
return 0;
#endif
}
static int mark_udp_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_UDP *udp = (Scheme_UDP *)p;
gcMARK2(udp->previous_from_addr, gc);
gcMARK2(udp->mref, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
# endif
#endif
}
static int mark_udp_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_UDP *udp = (Scheme_UDP *)p;
gcFIXUP2(udp->previous_from_addr, gc);
gcFIXUP2(udp->mref, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
# endif
#endif
}
#define mark_udp_IS_ATOMIC 0
@ -98,11 +143,15 @@ static int mark_udp_FIXUP(void *p, struct NewGC *gc) {
static int mark_udp_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
#else
return 0;
#endif
}
static int mark_udp_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
gcMARK2(uw->udp, gc);
@ -110,11 +159,17 @@ static int mark_udp_evt_MARK(void *p, struct NewGC *gc) {
gcMARK2(uw->dest_addrs, gc);
gcMARK2(uw->dest_addr_lens, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
# endif
#endif
}
static int mark_udp_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
gcFIXUP2(uw->udp, gc);
@ -122,8 +177,13 @@ static int mark_udp_evt_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(uw->dest_addrs, gc);
gcFIXUP2(uw->dest_addr_lens, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
# endif
#endif
}
#define mark_udp_evt_IS_ATOMIC 0

34
racket/src/racket/src/mzmark_optimize.inc
View File

@ -1,11 +1,15 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_optimize_info_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Optimize_Info));
#else
return 0;
#endif
}
static int mark_optimize_info_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Optimize_Info *i = (Optimize_Info *)p;
gcMARK2(i->stat_dists, gc);
@ -21,11 +25,17 @@ static int mark_optimize_info_MARK(void *p, struct NewGC *gc) {
gcMARK2(i->logger, gc);
gcMARK2(i->types, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Optimize_Info));
# endif
#endif
}
static int mark_optimize_info_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Optimize_Info *i = (Optimize_Info *)p;
gcFIXUP2(i->stat_dists, gc);
@ -41,8 +51,13 @@ static int mark_optimize_info_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(i->logger, gc);
gcFIXUP2(i->types, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Optimize_Info));
# endif
#endif
}
#define mark_optimize_info_IS_ATOMIC 0
@ -50,26 +65,41 @@ static int mark_optimize_info_FIXUP(void *p, struct NewGC *gc) {
static int mark_once_used_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used));
#else
return 0;
#endif
}
static int mark_once_used_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Once_Used *o = (Scheme_Once_Used *)p;
gcMARK2(o->expr, gc);
gcMARK2(o->info, gc);
gcMARK2(o->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used));
# endif
#endif
}
static int mark_once_used_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Once_Used *o = (Scheme_Once_Used *)p;
gcFIXUP2(o->expr, gc);
gcFIXUP2(o->info, gc);
gcFIXUP2(o->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used));
# endif
#endif
}
#define mark_once_used_IS_ATOMIC 0

102
racket/src/racket/src/mzmark_place.inc
View File

@ -1,24 +1,39 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int place_bi_channel_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel));
#else
return 0;
#endif
}
static int place_bi_channel_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p;
gcMARK2(pbc->link, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel));
# endif
#endif
}
static int place_bi_channel_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p;
gcFIXUP2(pbc->link, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel));
# endif
#endif
}
#define place_bi_channel_val_IS_ATOMIC 0
@ -26,18 +41,33 @@ static int place_bi_channel_val_FIXUP(void *p, struct NewGC *gc) {
static int place_object_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object));
#else
return 0;
#endif
}
static int place_object_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object));
# endif
#endif
}
static int place_object_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Object));
# endif
#endif
}
#define place_object_val_IS_ATOMIC 1
@ -45,11 +75,15 @@ static int place_object_val_FIXUP(void *p, struct NewGC *gc) {
static int place_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Place));
#else
return 0;
#endif
}
static int place_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Place *pr = (Scheme_Place *)p;
gcMARK2(pr->channel, gc);
gcMARK2(pr->mref, gc);
@ -58,11 +92,17 @@ static int place_val_MARK(void *p, struct NewGC *gc) {
gcMARK2(pr->prev, gc);
gcMARK2(pr->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place));
# endif
#endif
}
static int place_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Place *pr = (Scheme_Place *)p;
gcFIXUP2(pr->channel, gc);
gcFIXUP2(pr->mref, gc);
@ -71,8 +111,13 @@ static int place_val_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(pr->prev, gc);
gcFIXUP2(pr->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place));
# endif
#endif
}
#define place_val_IS_ATOMIC 0
@ -80,11 +125,15 @@ static int place_val_FIXUP(void *p, struct NewGC *gc) {
static int place_async_channel_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
#else
return 0;
#endif
}
static int place_async_channel_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p;
Scheme_Object *pr;
int i, j, sz;
@ -106,11 +155,17 @@ static int place_async_channel_val_MARK(void *p, struct NewGC *gc) {
j = ((j + 1) % sz);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
# endif
#endif
}
static int place_async_channel_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p;
Scheme_Object *pr;
int i, j, sz;
@ -132,8 +187,13 @@ static int place_async_channel_val_FIXUP(void *p, struct NewGC *gc) {
j = ((j + 1) % sz);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
# endif
#endif
}
#define place_async_channel_val_IS_ATOMIC 0
@ -141,24 +201,39 @@ static int place_async_channel_val_FIXUP(void *p, struct NewGC *gc) {
static int serialized_file_fd_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_File_FD));
#else
return 0;
#endif
}
static int serialized_file_fd_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Serialized_File_FD *ffd = (Scheme_Serialized_File_FD *) p;
gcMARK2(ffd->name, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_File_FD));
# endif
#endif
}
static int serialized_file_fd_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Serialized_File_FD *ffd = (Scheme_Serialized_File_FD *) p;
gcFIXUP2(ffd->name, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_File_FD));
# endif
#endif
}
#define serialized_file_fd_val_IS_ATOMIC 0
@ -166,24 +241,39 @@ static int serialized_file_fd_val_FIXUP(void *p, struct NewGC *gc) {
static int serialized_socket_fd_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_Socket_FD));
#else
return 0;
#endif
}
static int serialized_socket_fd_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Serialized_Socket_FD *sfd = (Scheme_Serialized_Socket_FD *) p;
gcMARK2(sfd->name, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_Socket_FD));
# endif
#endif
}
static int serialized_socket_fd_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Serialized_Socket_FD *sfd = (Scheme_Serialized_Socket_FD *) p;
gcFIXUP2(sfd->name, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Serialized_Socket_FD));
# endif
#endif
}
#define serialized_socket_fd_val_IS_ATOMIC 0

136
racket/src/racket/src/mzmark_port.inc
View File

@ -1,26 +1,41 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_input_file_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
#else
return 0;
#endif
}
static int mark_input_file_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Input_File *i = (Scheme_Input_File *)p;
gcMARK2(i->f, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
# endif
#endif
}
static int mark_input_file_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Input_File *i = (Scheme_Input_File *)p;
gcFIXUP2(i->f, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
# endif
#endif
}
#define mark_input_file_IS_ATOMIC 0
@ -28,26 +43,41 @@ static int mark_input_file_FIXUP(void *p, struct NewGC *gc) {
static int mark_output_file_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
#else
return 0;
#endif
}
static int mark_output_file_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Output_File *o = (Scheme_Output_File *)p;
gcMARK2(o->f, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
# endif
#endif
}
static int mark_output_file_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Output_File *o = (Scheme_Output_File *)p;
gcFIXUP2(o->f, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
# endif
#endif
}
#define mark_output_file_IS_ATOMIC 0
@ -56,30 +86,45 @@ static int mark_output_file_FIXUP(void *p, struct NewGC *gc) {
#ifdef MZ_FDS
static int mark_input_fd_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_FD));
#else
return 0;
#endif
}
static int mark_input_fd_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_FD *fd = (Scheme_FD *)p;
gcMARK2(fd->buffer, gc);
gcMARK2(fd->refcount, gc);
gcMARK2(fd->flush_handle, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_FD));
# endif
#endif
}
static int mark_input_fd_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_FD *fd = (Scheme_FD *)p;
gcFIXUP2(fd->buffer, gc);
gcFIXUP2(fd->refcount, gc);
gcFIXUP2(fd->flush_handle, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_FD));
# endif
#endif
}
#define mark_input_fd_IS_ATOMIC 0
@ -89,26 +134,41 @@ static int mark_input_fd_FIXUP(void *p, struct NewGC *gc) {
#if defined(UNIX_PROCESSES) && !(defined(MZ_USE_PLACES) && defined(MZ_PRECISE_GC))
static int mark_system_child_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(System_Child));
#else
return 0;
#endif
}
static int mark_system_child_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
System_Child *sc = (System_Child *)p;
gcMARK2(sc->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(System_Child));
# endif
#endif
}
static int mark_system_child_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
System_Child *sc = (System_Child *)p;
gcFIXUP2(sc->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(System_Child));
# endif
#endif
}
#define mark_system_child_IS_ATOMIC 0
@ -118,28 +178,43 @@ static int mark_system_child_FIXUP(void *p, struct NewGC *gc) {
#ifdef USE_OSKIT_CONSOLE
static int mark_oskit_console_input_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(osk_console_input));
#else
return 0;
#endif
}
static int mark_oskit_console_input_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
osk_console_input *c = (osk_console_input *)p;
gcMARK2(c->buffer, gc);
gcMARK2(c->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(osk_console_input));
# endif
#endif
}
static int mark_oskit_console_input_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
osk_console_input *c = (osk_console_input *)p;
gcFIXUP2(c->buffer, gc);
gcFIXUP2(c->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(osk_console_input));
# endif
#endif
}
#define mark_oskit_console_input_IS_ATOMIC 0
@ -148,28 +223,43 @@ static int mark_oskit_console_input_FIXUP(void *p, struct NewGC *gc) {
#endif
static int mark_subprocess_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
#else
return 0;
#endif
}
static int mark_subprocess_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
#ifndef WINDOWS_PROCESSES
Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
gcMARK2(sp->handle, gc);
gcMARK2(sp->mref, gc);
#endif
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
# endif
#endif
}
static int mark_subprocess_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
#ifndef WINDOWS_PROCESSES
Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
gcFIXUP2(sp->handle, gc);
gcFIXUP2(sp->mref, gc);
#endif
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
# endif
#endif
}
#define mark_subprocess_IS_ATOMIC 0
@ -177,26 +267,41 @@ static int mark_subprocess_FIXUP(void *p, struct NewGC *gc) {
static int mark_read_write_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
#else
return 0;
#endif
}
static int mark_read_write_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
gcMARK2(rww->port, gc);
gcMARK2(rww->v, gc);
gcMARK2(rww->str, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
# endif
#endif
}
static int mark_read_write_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
gcFIXUP2(rww->port, gc);
gcFIXUP2(rww->v, gc);
gcFIXUP2(rww->str, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
# endif
#endif
}
#define mark_read_write_evt_IS_ATOMIC 0
@ -204,24 +309,39 @@ static int mark_read_write_evt_FIXUP(void *p, struct NewGC *gc) {
static int mark_filesystem_change_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Filesystem_Change_Evt));
#else
return 0;
#endif
}
static int mark_filesystem_change_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)p;
gcMARK2(fc->sema, gc);
gcMARK2(fc->mref, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Filesystem_Change_Evt));
# endif
#endif
}
static int mark_filesystem_change_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)p;
gcFIXUP2(fc->sema, gc);
gcFIXUP2(fc->mref, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Filesystem_Change_Evt));
# endif
#endif
}
#define mark_filesystem_change_evt_IS_ATOMIC 0

68
racket/src/racket/src/mzmark_portfun.inc
View File

@ -1,11 +1,15 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_load_handler_data_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
#else
return 0;
#endif
}
static int mark_load_handler_data_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
LoadHandlerData *d = (LoadHandlerData *)p;
gcMARK2(d->config, gc);
@ -14,11 +18,17 @@ static int mark_load_handler_data_MARK(void *p, struct NewGC *gc) {
gcMARK2(d->stxsrc, gc);
gcMARK2(d->expected_module, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
# endif
#endif
}
static int mark_load_handler_data_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
LoadHandlerData *d = (LoadHandlerData *)p;
gcFIXUP2(d->config, gc);
@ -27,8 +37,13 @@ static int mark_load_handler_data_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(d->stxsrc, gc);
gcFIXUP2(d->expected_module, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
# endif
#endif
}
#define mark_load_handler_data_IS_ATOMIC 0
@ -36,26 +51,41 @@ static int mark_load_handler_data_FIXUP(void *p, struct NewGC *gc) {
static int mark_indexed_string_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
#else
return 0;
#endif
}
static int mark_indexed_string_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
gcMARK2(is->string, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
# endif
#endif
}
static int mark_indexed_string_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
gcFIXUP2(is->string, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
# endif
#endif
}
#define mark_indexed_string_IS_ATOMIC 0
@ -63,11 +93,15 @@ static int mark_indexed_string_FIXUP(void *p, struct NewGC *gc) {
static int mark_user_input_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(User_Input_Port));
#else
return 0;
#endif
}
static int mark_user_input_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
User_Input_Port *uip = (User_Input_Port *)p;
gcMARK2(uip->read_proc, gc);
@ -81,11 +115,17 @@ static int mark_user_input_MARK(void *p, struct NewGC *gc) {
gcMARK2(uip->reuse_str, gc);
gcMARK2(uip->peeked, gc);
gcMARK2(uip->prefix_pipe, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(User_Input_Port));
# endif
#endif
}
static int mark_user_input_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
User_Input_Port *uip = (User_Input_Port *)p;
gcFIXUP2(uip->read_proc, gc);
@ -99,8 +139,13 @@ static int mark_user_input_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(uip->reuse_str, gc);
gcFIXUP2(uip->peeked, gc);
gcFIXUP2(uip->prefix_pipe, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(User_Input_Port));
# endif
#endif
}
#define mark_user_input_IS_ATOMIC 0
@ -108,11 +153,15 @@ static int mark_user_input_FIXUP(void *p, struct NewGC *gc) {
static int mark_user_output_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(User_Output_Port));
#else
return 0;
#endif
}
static int mark_user_output_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
User_Output_Port *uop = (User_Output_Port *)p;
gcMARK2(uop->evt, gc);
@ -125,11 +174,17 @@ static int mark_user_output_MARK(void *p, struct NewGC *gc) {
gcMARK2(uop->buffer_mode_proc, gc);
gcMARK2(uop->close_proc, gc);
gcMARK2(uop->buffer_pipe, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(User_Output_Port));
# endif
#endif
}
static int mark_user_output_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
User_Output_Port *uop = (User_Output_Port *)p;
gcFIXUP2(uop->evt, gc);
@ -142,8 +197,13 @@ static int mark_user_output_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(uop->buffer_mode_proc, gc);
gcFIXUP2(uop->close_proc, gc);
gcFIXUP2(uop->buffer_pipe, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(User_Output_Port));
# endif
#endif
}
#define mark_user_output_IS_ATOMIC 0

34
racket/src/racket/src/mzmark_print.inc
View File

@ -1,30 +1,45 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_print_params_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(PrintParams));
#else
return 0;
#endif
}
static int mark_print_params_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
PrintParams *pp = (PrintParams *)p;
gcMARK2(pp->inspector, gc);
gcMARK2(pp->print_port, gc);
gcMARK2(pp->print_buffer, gc);
gcMARK2(pp->depth_delta, gc);
gcMARK2(pp->uq_ht, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(PrintParams));
# endif
#endif
}
static int mark_print_params_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
PrintParams *pp = (PrintParams *)p;
gcFIXUP2(pp->inspector, gc);
gcFIXUP2(pp->print_port, gc);
gcFIXUP2(pp->print_buffer, gc);
gcFIXUP2(pp->depth_delta, gc);
gcFIXUP2(pp->uq_ht, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(PrintParams));
# endif
#endif
}
#define mark_print_params_IS_ATOMIC 0
@ -32,11 +47,15 @@ static int mark_print_params_FIXUP(void *p, struct NewGC *gc) {
static int mark_marshal_tables_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
#else
return 0;
#endif
}
static int mark_marshal_tables_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
gcMARK2(mt->symtab, gc);
gcMARK2(mt->st_refs, gc);
@ -55,11 +74,17 @@ static int mark_marshal_tables_MARK(void *p, struct NewGC *gc) {
gcMARK2(mt->shared_offsets, gc);
gcMARK2(mt->path_cache, gc);
gcMARK2(mt->sorted_keys, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
# endif
#endif
}
static int mark_marshal_tables_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
gcFIXUP2(mt->symtab, gc);
gcFIXUP2(mt->st_refs, gc);
@ -78,8 +103,13 @@ static int mark_marshal_tables_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(mt->shared_offsets, gc);
gcFIXUP2(mt->path_cache, gc);
gcFIXUP2(mt->sorted_keys, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
# endif
#endif
}
#define mark_marshal_tables_IS_ATOMIC 0

102
racket/src/racket/src/mzmark_read.inc
View File

@ -1,18 +1,33 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_indent_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
#else
return 0;
#endif
}
static int mark_indent_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
# endif
#endif
}
static int mark_indent_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
# endif
#endif
}
#define mark_indent_IS_ATOMIC 1
@ -20,11 +35,15 @@ static int mark_indent_FIXUP(void *p, struct NewGC *gc) {
static int mark_cport_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(CPort));
#else
return 0;
#endif
}
static int mark_cport_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
CPort *cp = (CPort *)p;
gcMARK2(cp->start, gc);
gcMARK2(cp->orig_port, gc);
@ -37,11 +56,17 @@ static int mark_cport_MARK(void *p, struct NewGC *gc) {
gcMARK2(cp->shared_offsets, gc);
gcMARK2(cp->delay_info, gc);
gcMARK2(cp->symtab_refs, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(CPort));
# endif
#endif
}
static int mark_cport_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
CPort *cp = (CPort *)p;
gcFIXUP2(cp->start, gc);
gcFIXUP2(cp->orig_port, gc);
@ -54,8 +79,13 @@ static int mark_cport_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(cp->shared_offsets, gc);
gcFIXUP2(cp->delay_info, gc);
gcFIXUP2(cp->symtab_refs, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(CPort));
# endif
#endif
}
#define mark_cport_IS_ATOMIC 0
@ -63,28 +93,43 @@ static int mark_cport_FIXUP(void *p, struct NewGC *gc) {
static int mark_readtable_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Readtable));
#else
return 0;
#endif
}
static int mark_readtable_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Readtable *t = (Readtable *)p;
gcMARK2(t->mapping, gc);
gcMARK2(t->fast_mapping, gc);
gcMARK2(t->symbol_parser, gc);
gcMARK2(t->names, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Readtable));
# endif
#endif
}
static int mark_readtable_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Readtable *t = (Readtable *)p;
gcFIXUP2(t->mapping, gc);
gcFIXUP2(t->fast_mapping, gc);
gcFIXUP2(t->symbol_parser, gc);
gcFIXUP2(t->names, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Readtable));
# endif
#endif
}
#define mark_readtable_IS_ATOMIC 0
@ -92,30 +137,45 @@ static int mark_readtable_FIXUP(void *p, struct NewGC *gc) {
static int mark_read_params_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(ReadParams));
#else
return 0;
#endif
}
static int mark_read_params_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
ReadParams *rp = (ReadParams *)p;
gcMARK2(rp->table, gc);
gcMARK2(rp->magic_sym, gc);
gcMARK2(rp->magic_val, gc);
gcMARK2(rp->delay_load_info, gc);
gcMARK2(rp->read_relative_path, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(ReadParams));
# endif
#endif
}
static int mark_read_params_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
ReadParams *rp = (ReadParams *)p;
gcFIXUP2(rp->table, gc);
gcFIXUP2(rp->magic_sym, gc);
gcFIXUP2(rp->magic_val, gc);
gcFIXUP2(rp->delay_load_info, gc);
gcFIXUP2(rp->read_relative_path, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(ReadParams));
# endif
#endif
}
#define mark_read_params_IS_ATOMIC 0
@ -123,11 +183,15 @@ static int mark_read_params_FIXUP(void *p, struct NewGC *gc) {
static int mark_delay_load_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
#else
return 0;
#endif
}
static int mark_delay_load_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
gcMARK2(ld->path, gc);
gcMARK2(ld->symtab, gc);
@ -137,11 +201,17 @@ static int mark_delay_load_MARK(void *p, struct NewGC *gc) {
gcMARK2(ld->current_rp, gc);
gcMARK2(ld->cached, gc);
gcMARK2(ld->cached_port, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
# endif
#endif
}
static int mark_delay_load_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
gcFIXUP2(ld->path, gc);
gcFIXUP2(ld->symtab, gc);
@ -151,8 +221,13 @@ static int mark_delay_load_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(ld->current_rp, gc);
gcFIXUP2(ld->cached, gc);
gcFIXUP2(ld->cached_port, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
# endif
#endif
}
#define mark_delay_load_IS_ATOMIC 0
@ -160,28 +235,43 @@ static int mark_delay_load_FIXUP(void *p, struct NewGC *gc) {
static int mark_unmarshal_tables_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
#else
return 0;
#endif
}
static int mark_unmarshal_tables_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
gcMARK2(ut->rns, gc);
gcMARK2(ut->multi_scope_pairs, gc);
gcMARK2(ut->rp, gc);
gcMARK2(ut->decoded, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
# endif
#endif
}
static int mark_unmarshal_tables_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
gcFIXUP2(ut->rns, gc);
gcFIXUP2(ut->multi_scope_pairs, gc);
gcFIXUP2(ut->rp, gc);
gcFIXUP2(ut->decoded, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
# endif
#endif
}
#define mark_unmarshal_tables_IS_ATOMIC 0

51
racket/src/racket/src/mzmark_regexp.inc
View File

@ -1,25 +1,40 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_regexp_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
regexp *r = (regexp *)p;
return
gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
#else
return 0;
#endif
}
static int mark_regexp_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
regexp *r = (regexp *)p;
gcMARK2(r->source, gc);
gcMARK2(r->regstart, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
# endif
#endif
}
static int mark_regexp_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
regexp *r = (regexp *)p;
gcFIXUP2(r->source, gc);
gcFIXUP2(r->regstart, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
# endif
#endif
}
#define mark_regexp_IS_ATOMIC 0
@ -27,11 +42,15 @@ static int mark_regexp_FIXUP(void *p, struct NewGC *gc) {
static int mark_regwork_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Regwork));
#else
return 0;
#endif
}
static int mark_regwork_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Regwork *r = (Regwork *)p;
gcMARK2(r->str, gc);
gcMARK2(r->instr, gc);
@ -45,11 +64,17 @@ static int mark_regwork_MARK(void *p, struct NewGC *gc) {
gcMARK2(r->prefix, gc);
gcMARK2(r->lazy_string, gc);
gcMARK2(r->rewind_stack, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Regwork));
# endif
#endif
}
static int mark_regwork_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Regwork *r = (Regwork *)p;
gcFIXUP2(r->str, gc);
gcFIXUP2(r->instr, gc);
@ -63,8 +88,13 @@ static int mark_regwork_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(r->prefix, gc);
gcFIXUP2(r->lazy_string, gc);
gcFIXUP2(r->rewind_stack, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Regwork));
# endif
#endif
}
#define mark_regwork_IS_ATOMIC 0
@ -72,24 +102,39 @@ static int mark_regwork_FIXUP(void *p, struct NewGC *gc) {
static int mark_lazy_string_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(rx_lazy_str_t));
#else
return 0;
#endif
}
static int mark_lazy_string_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
rx_lazy_str_t *ls = (rx_lazy_str_t *)p;
gcMARK2(ls->s, gc);
gcMARK2(ls->chars, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(rx_lazy_str_t));
# endif
#endif
}
static int mark_lazy_string_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
rx_lazy_str_t *ls = (rx_lazy_str_t *)p;
gcFIXUP2(ls->s, gc);
gcFIXUP2(ls->chars, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(rx_lazy_str_t));
# endif
#endif
}
#define mark_lazy_string_IS_ATOMIC 0

34
racket/src/racket/src/mzmark_resolve.inc
View File

@ -1,11 +1,15 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_resolve_info_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Resolve_Info));
#else
return 0;
#endif
}
static int mark_resolve_info_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Resolve_Info *i = (Resolve_Info *)p;
gcMARK2(i->prefix, gc);
@ -19,11 +23,17 @@ static int mark_resolve_info_MARK(void *p, struct NewGC *gc) {
gcMARK2(i->lifted, gc);
gcMARK2(i->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Resolve_Info));
# endif
#endif
}
static int mark_resolve_info_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Resolve_Info *i = (Resolve_Info *)p;
gcFIXUP2(i->prefix, gc);
@ -37,8 +47,13 @@ static int mark_resolve_info_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(i->lifted, gc);
gcFIXUP2(i->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Resolve_Info));
# endif
#endif
}
#define mark_resolve_info_IS_ATOMIC 0
@ -46,11 +61,15 @@ static int mark_resolve_info_FIXUP(void *p, struct NewGC *gc) {
static int mark_unresolve_info_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Unresolve_Info));
#else
return 0;
#endif
}
static int mark_unresolve_info_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Unresolve_Info *i = (Unresolve_Info *)p;
gcMARK2(i->flags, gc);
@ -65,11 +84,17 @@ static int mark_unresolve_info_MARK(void *p, struct NewGC *gc) {
gcMARK2(i->ref_args, gc);
gcMARK2(i->ref_lifts, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Unresolve_Info));
# endif
#endif
}
static int mark_unresolve_info_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Unresolve_Info *i = (Unresolve_Info *)p;
gcFIXUP2(i->flags, gc);
@ -84,8 +109,13 @@ static int mark_unresolve_info_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(i->ref_args, gc);
gcFIXUP2(i->ref_lifts, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Unresolve_Info));
# endif
#endif
}
#define mark_unresolve_info_IS_ATOMIC 0

34
racket/src/racket/src/mzmark_salloc.inc
View File

@ -1,30 +1,45 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_finalization_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Finalization));
#else
return 0;
#endif
}
static int mark_finalization_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Finalization *f = (Finalization *)p;
gcMARK2(f->data, gc);
gcMARK2(f->next, gc);
gcMARK2(f->prev, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Finalization));
# endif
#endif
}
static int mark_finalization_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Finalization *f = (Finalization *)p;
gcFIXUP2(f->data, gc);
gcFIXUP2(f->next, gc);
gcFIXUP2(f->prev, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Finalization));
# endif
#endif
}
#define mark_finalization_IS_ATOMIC 0
@ -32,11 +47,15 @@ static int mark_finalization_FIXUP(void *p, struct NewGC *gc) {
static int mark_finalizations_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Finalizations));
#else
return 0;
#endif
}
static int mark_finalizations_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Finalizations *f = (Finalizations *)p;
gcMARK2(f->scheme_first, gc);
@ -45,11 +64,17 @@ static int mark_finalizations_MARK(void *p, struct NewGC *gc) {
gcMARK2(f->prim_last, gc);
gcMARK2(f->ext_data, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Finalizations));
# endif
#endif
}
static int mark_finalizations_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Finalizations *f = (Finalizations *)p;
gcFIXUP2(f->scheme_first, gc);
@ -58,8 +83,13 @@ static int mark_finalizations_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(f->prim_last, gc);
gcFIXUP2(f->ext_data, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Finalizations));
# endif
#endif
}
#define mark_finalizations_IS_ATOMIC 0

34
racket/src/racket/src/mzmark_sema.inc
View File

@ -1,11 +1,15 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_channel_syncer_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
#else
return 0;
#endif
}
static int mark_channel_syncer_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
gcMARK2(w->p, gc);
@ -14,11 +18,17 @@ static int mark_channel_syncer_MARK(void *p, struct NewGC *gc) {
gcMARK2(w->syncing, gc);
gcMARK2(w->obj, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
# endif
#endif
}
static int mark_channel_syncer_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
gcFIXUP2(w->p, gc);
@ -27,8 +37,13 @@ static int mark_channel_syncer_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(w->syncing, gc);
gcFIXUP2(w->obj, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
# endif
#endif
}
#define mark_channel_syncer_IS_ATOMIC 0
@ -36,18 +51,33 @@ static int mark_channel_syncer_FIXUP(void *p, struct NewGC *gc) {
static int mark_alarm_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
#else
return 0;
#endif
}
static int mark_alarm_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
# endif
#endif
}
static int mark_alarm_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
# endif
#endif
}
#define mark_alarm_IS_ATOMIC 1

17
racket/src/racket/src/mzmark_sfs.inc
View File

@ -1,30 +1,45 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_sfs_info_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(SFS_Info));
#else
return 0;
#endif
}
static int mark_sfs_info_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
SFS_Info *i = (SFS_Info *)p;
gcMARK2(i->max_used, gc);
gcMARK2(i->max_calls, gc);
gcMARK2(i->saved, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(SFS_Info));
# endif
#endif
}
static int mark_sfs_info_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
SFS_Info *i = (SFS_Info *)p;
gcFIXUP2(i->max_used, gc);
gcFIXUP2(i->max_calls, gc);
gcFIXUP2(i->saved, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(SFS_Info));
# endif
#endif
}
#define mark_sfs_info_IS_ATOMIC 0

17
racket/src/racket/src/mzmark_string.inc
View File

@ -1,22 +1,37 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_string_convert_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
#else
return 0;
#endif
}
static int mark_string_convert_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Converter *c = (Scheme_Converter *)p;
gcMARK2(c->mref, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
# endif
#endif
}
static int mark_string_convert_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Converter *c = (Scheme_Converter *)p;
gcFIXUP2(c->mref, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
# endif
#endif
}
#define mark_string_convert_IS_ATOMIC 0

136
racket/src/racket/src/mzmark_struct.inc
View File

@ -2,15 +2,19 @@
#ifdef MZ_USE_PLACES
static int mark_serialized_struct_val_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
int num_slots = s->num_slots;
return
gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
+ ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
#else
return 0;
#endif
}
static int mark_serialized_struct_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
int num_slots = s->num_slots;
@ -21,12 +25,18 @@ static int mark_serialized_struct_val_MARK(void *p, struct NewGC *gc) {
for(i = num_slots; i--; )
gcMARK2(s->slots[i], gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
+ ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
# endif
#endif
}
static int mark_serialized_struct_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
int num_slots = s->num_slots;
@ -37,9 +47,14 @@ static int mark_serialized_struct_val_FIXUP(void *p, struct NewGC *gc) {
for(i = num_slots; i--; )
gcFIXUP2(s->slots[i], gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
+ ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
# endif
#endif
}
#define mark_serialized_struct_val_IS_ATOMIC 0
@ -48,15 +63,19 @@ static int mark_serialized_struct_val_FIXUP(void *p, struct NewGC *gc) {
#endif
static int mark_struct_val_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
Scheme_Structure *s = (Scheme_Structure *)p;
int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
return
gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
+ ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
#else
return 0;
#endif
}
static int mark_struct_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Structure *s = (Scheme_Structure *)p;
int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
@ -67,12 +86,18 @@ static int mark_struct_val_MARK(void *p, struct NewGC *gc) {
for(i = num_slots; i--; )
gcMARK2(s->slots[i], gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
+ ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
# endif
#endif
}
static int mark_struct_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Structure *s = (Scheme_Structure *)p;
int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
@ -83,9 +108,14 @@ static int mark_struct_val_FIXUP(void *p, struct NewGC *gc) {
for(i = num_slots; i--; )
gcFIXUP2(s->slots[i], gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
+ ((num_slots - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
# endif
#endif
}
#define mark_struct_val_IS_ATOMIC 0
@ -93,15 +123,19 @@ static int mark_struct_val_FIXUP(void *p, struct NewGC *gc) {
static int mark_struct_type_val_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
return
gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
+ ((t->name_pos + 1 - mzFLEX_DELTA)
* sizeof(Scheme_Struct_Type *))));
#else
return 0;
#endif
}
static int mark_struct_type_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
int i;
@ -119,13 +153,19 @@ static int mark_struct_type_val_MARK(void *p, struct NewGC *gc) {
gcMARK2(t->guard, gc);
gcMARK2(t->immutables, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
+ ((t->name_pos + 1 - mzFLEX_DELTA)
* sizeof(Scheme_Struct_Type *))));
# endif
#endif
}
static int mark_struct_type_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
int i;
@ -143,10 +183,15 @@ static int mark_struct_type_val_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(t->guard, gc);
gcFIXUP2(t->immutables, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
+ ((t->name_pos + 1 - mzFLEX_DELTA)
* sizeof(Scheme_Struct_Type *))));
# endif
#endif
}
#define mark_struct_type_val_IS_ATOMIC 0
@ -154,26 +199,41 @@ static int mark_struct_type_val_FIXUP(void *p, struct NewGC *gc) {
static int mark_struct_property_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
#else
return 0;
#endif
}
static int mark_struct_property_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
gcMARK2(i->name, gc);
gcMARK2(i->guard, gc);
gcMARK2(i->supers, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
# endif
#endif
}
static int mark_struct_property_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
gcFIXUP2(i->name, gc);
gcFIXUP2(i->guard, gc);
gcFIXUP2(i->supers, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
# endif
#endif
}
#define mark_struct_property_IS_ATOMIC 0
@ -181,28 +241,43 @@ static int mark_struct_property_FIXUP(void *p, struct NewGC *gc) {
static int mark_wrapped_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
#else
return 0;
#endif
}
static int mark_wrapped_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Wrapped_Evt *ww = (Wrapped_Evt *)p;
gcMARK2(ww->evt, gc);
gcMARK2(ww->wrapper, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
# endif
#endif
}
static int mark_wrapped_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Wrapped_Evt *ww = (Wrapped_Evt *)p;
gcFIXUP2(ww->evt, gc);
gcFIXUP2(ww->wrapper, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
# endif
#endif
}
#define mark_wrapped_evt_IS_ATOMIC 0
@ -210,26 +285,41 @@ static int mark_wrapped_evt_FIXUP(void *p, struct NewGC *gc) {
static int mark_nack_guard_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
#else
return 0;
#endif
}
static int mark_nack_guard_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
gcMARK2(nw->maker, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
# endif
#endif
}
static int mark_nack_guard_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
gcFIXUP2(nw->maker, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
# endif
#endif
}
#define mark_nack_guard_evt_IS_ATOMIC 0
@ -237,30 +327,45 @@ static int mark_nack_guard_evt_FIXUP(void *p, struct NewGC *gc) {
static int mark_active_replace_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt));
#else
return 0;
#endif
}
static int mark_active_replace_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Active_Replace_Evt *a = (Active_Replace_Evt *)p;
gcMARK2(a->syncing, gc);
gcMARK2(a->wrapper, gc);
gcMARK2(a->orig, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt));
# endif
#endif
}
static int mark_active_replace_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Active_Replace_Evt *a = (Active_Replace_Evt *)p;
gcFIXUP2(a->syncing, gc);
gcFIXUP2(a->wrapper, gc);
gcFIXUP2(a->orig, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Active_Replace_Evt));
# endif
#endif
}
#define mark_active_replace_evt_IS_ATOMIC 0
@ -268,11 +373,15 @@ static int mark_active_replace_evt_FIXUP(void *p, struct NewGC *gc) {
static int mark_chaperone_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
#else
return 0;
#endif
}
static int mark_chaperone_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Chaperone *px = (Scheme_Chaperone *)p;
gcMARK2(px->val, gc);
@ -280,11 +389,17 @@ static int mark_chaperone_MARK(void *p, struct NewGC *gc) {
gcMARK2(px->props, gc);
gcMARK2(px->redirects, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
# endif
#endif
}
static int mark_chaperone_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Chaperone *px = (Scheme_Chaperone *)p;
gcFIXUP2(px->val, gc);
@ -292,8 +407,13 @@ static int mark_chaperone_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(px->props, gc);
gcFIXUP2(px->redirects, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
# endif
#endif
}
#define mark_chaperone_IS_ATOMIC 0

68
racket/src/racket/src/mzmark_syntax.inc
View File

@ -1,22 +1,37 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_srcloc_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
#else
return 0;
#endif
}
static int mark_srcloc_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
gcMARK2(s->src, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
# endif
#endif
}
static int mark_srcloc_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
gcFIXUP2(s->src, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
# endif
#endif
}
#define mark_srcloc_IS_ATOMIC 0
@ -24,15 +39,19 @@ static int mark_srcloc_FIXUP(void *p, struct NewGC *gc) {
static int mark_scope_SIZE(void *p, struct NewGC *gc) {
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
Scheme_Scope *m = (Scheme_Scope *)p;
int for_multi = SCHEME_SCOPE_HAS_OWNER(m);
return
(for_multi
? gcBYTES_TO_WORDS(sizeof(Scheme_Scope_With_Owner))
: gcBYTES_TO_WORDS(sizeof(Scheme_Scope)));
#else
return 0;
#endif
}
static int mark_scope_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Scope *m = (Scheme_Scope *)p;
int for_multi = SCHEME_SCOPE_HAS_OWNER(m);
gcMARK2(m->bindings, gc);
@ -40,13 +59,19 @@ static int mark_scope_MARK(void *p, struct NewGC *gc) {
gcMARK2(((Scheme_Scope_With_Owner *)m)->owner_multi_scope, gc);
gcMARK2(((Scheme_Scope_With_Owner *)m)->phase, gc);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
(for_multi
? gcBYTES_TO_WORDS(sizeof(Scheme_Scope_With_Owner))
: gcBYTES_TO_WORDS(sizeof(Scheme_Scope)));
# endif
#endif
}
static int mark_scope_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Scope *m = (Scheme_Scope *)p;
int for_multi = SCHEME_SCOPE_HAS_OWNER(m);
gcFIXUP2(m->bindings, gc);
@ -54,10 +79,15 @@ static int mark_scope_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(((Scheme_Scope_With_Owner *)m)->owner_multi_scope, gc);
gcFIXUP2(((Scheme_Scope_With_Owner *)m)->phase, gc);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
(for_multi
? gcBYTES_TO_WORDS(sizeof(Scheme_Scope_With_Owner))
: gcBYTES_TO_WORDS(sizeof(Scheme_Scope)));
# endif
#endif
}
#define mark_scope_IS_ATOMIC 0
@ -65,24 +95,39 @@ static int mark_scope_FIXUP(void *p, struct NewGC *gc) {
static int mark_scope_table_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Scope_Table));
#else
return 0;
#endif
}
static int mark_scope_table_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Scope_Table *m = (Scheme_Scope_Table *)p;
gcMARK2(m->simple_scopes, gc);
gcMARK2(m->multi_scopes, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Scope_Table));
# endif
#endif
}
static int mark_scope_table_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Scope_Table *m = (Scheme_Scope_Table *)p;
gcFIXUP2(m->simple_scopes, gc);
gcFIXUP2(m->multi_scopes, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Scope_Table));
# endif
#endif
}
#define mark_scope_table_IS_ATOMIC 0
@ -90,26 +135,41 @@ static int mark_scope_table_FIXUP(void *p, struct NewGC *gc) {
static int mark_propagate_table_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Propagate_Table));
#else
return 0;
#endif
}
static int mark_propagate_table_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Propagate_Table *m = (Scheme_Propagate_Table *)p;
mark_scope_table_MARK(&m->st, gc);
gcMARK2(m->prev, gc);
gcMARK2(m->phase_shift, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Propagate_Table));
# endif
#endif
}
static int mark_propagate_table_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Propagate_Table *m = (Scheme_Propagate_Table *)p;
mark_scope_table_FIXUP(&m->st, gc);
gcFIXUP2(m->prev, gc);
gcFIXUP2(m->phase_shift, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Propagate_Table));
# endif
#endif
}
#define mark_propagate_table_IS_ATOMIC 0

238
racket/src/racket/src/mzmark_thread.inc
View File

@ -1,12 +1,16 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_parameterization_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
+ ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*))));
#else
return 0;
#endif
}
static int mark_parameterization_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Parameterization *c = (Scheme_Parameterization *)p;
int i;
@ -15,12 +19,18 @@ static int mark_parameterization_MARK(void *p, struct NewGC *gc) {
}
gcMARK2(c->extensions, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
+ ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*))));
# endif
#endif
}
static int mark_parameterization_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Parameterization *c = (Scheme_Parameterization *)p;
int i;
@ -29,9 +39,14 @@ static int mark_parameterization_FIXUP(void *p, struct NewGC *gc) {
}
gcFIXUP2(c->extensions, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
+ ((max_configs - mzFLEX_DELTA) * sizeof(Scheme_Object*))));
# endif
#endif
}
#define mark_parameterization_IS_ATOMIC 0
@ -39,24 +54,39 @@ static int mark_parameterization_FIXUP(void *p, struct NewGC *gc) {
static int mark_config_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Config));
#else
return 0;
#endif
}
static int mark_config_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Config *config = (Scheme_Config *)p;
gcMARK2(config->ht, gc);
gcMARK2(config->root, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Config));
# endif
#endif
}
static int mark_config_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Config *config = (Scheme_Config *)p;
gcFIXUP2(config->ht, gc);
gcFIXUP2(config->root, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Config));
# endif
#endif
}
#define mark_config_IS_ATOMIC 0
@ -64,30 +94,45 @@ static int mark_config_FIXUP(void *p, struct NewGC *gc) {
static int mark_will_executor_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(WillExecutor));
#else
return 0;
#endif
}
static int mark_will_executor_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
WillExecutor *e = (WillExecutor *)p;
gcMARK2(e->sema, gc);
gcMARK2(e->first, gc);
gcMARK2(e->last, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(WillExecutor));
# endif
#endif
}
static int mark_will_executor_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
WillExecutor *e = (WillExecutor *)p;
gcFIXUP2(e->sema, gc);
gcFIXUP2(e->first, gc);
gcFIXUP2(e->last, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(WillExecutor));
# endif
#endif
}
#define mark_will_executor_val_IS_ATOMIC 0
@ -95,11 +140,15 @@ static int mark_will_executor_val_FIXUP(void *p, struct NewGC *gc) {
static int mark_custodian_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
#else
return 0;
#endif
}
static int mark_custodian_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Custodian *m = (Scheme_Custodian *)p;
gcMARK2(m->boxes, gc);
@ -117,11 +166,17 @@ static int mark_custodian_val_MARK(void *p, struct NewGC *gc) {
gcMARK2(m->cust_boxes, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
# endif
#endif
}
static int mark_custodian_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Custodian *m = (Scheme_Custodian *)p;
gcFIXUP2(m->boxes, gc);
@ -139,8 +194,13 @@ static int mark_custodian_val_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(m->cust_boxes, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
# endif
#endif
}
#define mark_custodian_val_IS_ATOMIC 0
@ -148,11 +208,15 @@ static int mark_custodian_val_FIXUP(void *p, struct NewGC *gc) {
static int mark_custodian_box_val_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
#else
return 0;
#endif
}
static int mark_custodian_box_val_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down;
@ -161,11 +225,17 @@ static int mark_custodian_box_val_MARK(void *p, struct NewGC *gc) {
gcMARK2(b->v, gc);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
# endif
#endif
}
static int mark_custodian_box_val_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down;
@ -174,8 +244,13 @@ static int mark_custodian_box_val_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(b->v, gc);
}
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
# endif
#endif
}
#define mark_custodian_box_val_IS_ATOMIC 0
@ -183,26 +258,41 @@ static int mark_custodian_box_val_FIXUP(void *p, struct NewGC *gc) {
static int mark_thread_hop_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
#else
return 0;
#endif
}
static int mark_thread_hop_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
gcMARK2(hop->p, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
# endif
#endif
}
static int mark_thread_hop_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
gcFIXUP2(hop->p, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
# endif
#endif
}
#define mark_thread_hop_IS_ATOMIC 0
@ -210,11 +300,15 @@ static int mark_thread_hop_FIXUP(void *p, struct NewGC *gc) {
static int mark_param_data_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(ParamData));
#else
return 0;
#endif
}
static int mark_param_data_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
ParamData *d = (ParamData *)p;
gcMARK2(d->key, gc);
@ -222,11 +316,17 @@ static int mark_param_data_MARK(void *p, struct NewGC *gc) {
gcMARK2(d->extract_guard, gc);
gcMARK2(d->defcell, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(ParamData));
# endif
#endif
}
static int mark_param_data_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
ParamData *d = (ParamData *)p;
gcFIXUP2(d->key, gc);
@ -234,8 +334,13 @@ static int mark_param_data_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(d->extract_guard, gc);
gcFIXUP2(d->defcell, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(ParamData));
# endif
#endif
}
#define mark_param_data_IS_ATOMIC 0
@ -243,11 +348,15 @@ static int mark_param_data_FIXUP(void *p, struct NewGC *gc) {
static int mark_will_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(ActiveWill));
#else
return 0;
#endif
}
static int mark_will_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
ActiveWill *w = (ActiveWill *)p;
gcMARK2(w->o, gc);
@ -255,11 +364,17 @@ static int mark_will_MARK(void *p, struct NewGC *gc) {
gcMARK2(w->w, gc);
gcMARK2(w->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(ActiveWill));
# endif
#endif
}
static int mark_will_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
ActiveWill *w = (ActiveWill *)p;
gcFIXUP2(w->o, gc);
@ -267,8 +382,13 @@ static int mark_will_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(w->w, gc);
gcFIXUP2(w->next, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(ActiveWill));
# endif
#endif
}
#define mark_will_IS_ATOMIC 0
@ -276,18 +396,33 @@ static int mark_will_FIXUP(void *p, struct NewGC *gc) {
static int mark_evt_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Evt));
#else
return 0;
#endif
}
static int mark_evt_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Evt));
# endif
#endif
}
static int mark_evt_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Evt));
# endif
#endif
}
#define mark_evt_IS_ATOMIC 1
@ -295,11 +430,15 @@ static int mark_evt_FIXUP(void *p, struct NewGC *gc) {
static int mark_syncing_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Syncing));
#else
return 0;
#endif
}
static int mark_syncing_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Syncing *w = (Syncing *)p;
gcMARK2(w->set, gc);
@ -310,11 +449,17 @@ static int mark_syncing_MARK(void *p, struct NewGC *gc) {
gcMARK2(w->disable_break, gc);
gcMARK2(w->thread, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Syncing));
# endif
#endif
}
static int mark_syncing_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Syncing *w = (Syncing *)p;
gcFIXUP2(w->set, gc);
@ -325,8 +470,13 @@ static int mark_syncing_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(w->disable_break, gc);
gcFIXUP2(w->thread, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Syncing));
# endif
#endif
}
#define mark_syncing_IS_ATOMIC 0
@ -334,28 +484,43 @@ static int mark_syncing_FIXUP(void *p, struct NewGC *gc) {
static int mark_evt_set_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Evt_Set));
#else
return 0;
#endif
}
static int mark_evt_set_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Evt_Set *w = (Evt_Set *)p;
gcMARK2(w->ws, gc);
gcMARK2(w->argv, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Evt_Set));
# endif
#endif
}
static int mark_evt_set_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Evt_Set *w = (Evt_Set *)p;
gcFIXUP2(w->ws, gc);
gcFIXUP2(w->argv, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Evt_Set));
# endif
#endif
}
#define mark_evt_set_IS_ATOMIC 0
@ -363,11 +528,15 @@ static int mark_evt_set_FIXUP(void *p, struct NewGC *gc) {
static int mark_thread_set_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
#else
return 0;
#endif
}
static int mark_thread_set_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
gcMARK2(ts->parent, gc);
@ -377,11 +546,17 @@ static int mark_thread_set_MARK(void *p, struct NewGC *gc) {
gcMARK2(ts->search_start, gc);
gcMARK2(ts->current, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
# endif
#endif
}
static int mark_thread_set_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
gcFIXUP2(ts->parent, gc);
@ -391,8 +566,13 @@ static int mark_thread_set_FIXUP(void *p, struct NewGC *gc) {
gcFIXUP2(ts->search_start, gc);
gcFIXUP2(ts->current, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
# endif
#endif
}
#define mark_thread_set_IS_ATOMIC 0
@ -400,26 +580,41 @@ static int mark_thread_set_FIXUP(void *p, struct NewGC *gc) {
static int mark_thread_cell_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Thread_Cell));
#else
return 0;
#endif
}
static int mark_thread_cell_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Thread_Cell *c = (Thread_Cell *)p;
gcMARK2(c->def_val, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Thread_Cell));
# endif
#endif
}
static int mark_thread_cell_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Thread_Cell *c = (Thread_Cell *)p;
gcFIXUP2(c->def_val, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Thread_Cell));
# endif
#endif
}
#define mark_thread_cell_IS_ATOMIC 0
@ -427,28 +622,43 @@ static int mark_thread_cell_FIXUP(void *p, struct NewGC *gc) {
static int mark_plumber_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Scheme_Plumber));
#else
return 0;
#endif
}
static int mark_plumber_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Scheme_Plumber *pl = (Scheme_Plumber *)p;
gcMARK2(pl->handles, gc);
gcMARK2(pl->weak_handles, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Plumber));
# endif
#endif
}
static int mark_plumber_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Scheme_Plumber *pl = (Scheme_Plumber *)p;
gcFIXUP2(pl->handles, gc);
gcFIXUP2(pl->weak_handles, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Scheme_Plumber));
# endif
#endif
}
#define mark_plumber_IS_ATOMIC 0

1480
racket/src/racket/src/mzmark_type.inc
View File

File diff suppressed because it is too large Load Diff

17
racket/src/racket/src/mzmark_validate.inc
View File

@ -1,28 +1,43 @@
/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */
static int mark_validate_clearing_SIZE(void *p, struct NewGC *gc) {
return
#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS
gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
#else
return 0;
#endif
}
static int mark_validate_clearing_MARK(void *p, struct NewGC *gc) {
#ifndef GC_NO_MARK_PROCEDURE_NEEDED
Validate_Clearing *vc = (Validate_Clearing *)p;
gcMARK2(vc->stack, gc);
gcMARK2(vc->ncstack, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
# endif
#endif
}
static int mark_validate_clearing_FIXUP(void *p, struct NewGC *gc) {
#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED
Validate_Clearing *vc = (Validate_Clearing *)p;
gcFIXUP2(vc->stack, gc);
gcFIXUP2(vc->ncstack, gc);
# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS
return 0;
# else
return
gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
# endif
#endif
}
#define mark_validate_clearing_IS_ATOMIC 0

31
racket/src/racket/src/mzmarksrc.c
View File

@ -565,11 +565,9 @@ bstring_obj {
}
symbol_obj {
Scheme_Symbol *s = (Scheme_Symbol *)p;
mark:
size:
gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + s->len + 1 - mzFLEX4_DELTA);
gcBYTES_TO_WORDS(sizeof(Scheme_Symbol) + ((Scheme_Symbol *)p)->len + 1 - mzFLEX4_DELTA);
}
cons_cell {
@ -597,31 +595,25 @@ vector_obj {
}
fxvector_obj {
Scheme_Vector *vec = (Scheme_Vector *)p;
mark:
size:
gcBYTES_TO_WORDS((sizeof(Scheme_Vector)
+ ((vec->size - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
+ ((((Scheme_Vector *)p)->size - mzFLEX_DELTA) * sizeof(Scheme_Object *))));
}
flvector_obj {
Scheme_Double_Vector *vec = (Scheme_Double_Vector *)p;
mark:
size:
gcBYTES_TO_WORDS((sizeof(Scheme_Double_Vector)
+ ((vec->size - mzFLEX_DELTA) * sizeof(double))));
+ ((((Scheme_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(double))));
}
#ifdef MZ_LONG_DOUBLE
extflvector_obj {
Scheme_Long_Double_Vector *vec = (Scheme_Long_Double_Vector *)p;
mark:
size:
gcBYTES_TO_WORDS((sizeof(Scheme_Long_Double_Vector)
+ ((vec->size - mzFLEX_DELTA) * sizeof(long double))));
+ ((((Scheme_Long_Double_Vector *)p)->size - mzFLEX_DELTA) * sizeof(long double))));
}
#endif
@ -771,8 +763,6 @@ thread_val {
gcMARK2(pr->self_for_proc_chaperone, gc);
gcMARK2(pr->list_stack, gc);
gcMARK2(pr->kill_data, gc);
gcMARK2(pr->private_kill_data, gc);
gcMARK2(pr->private_kill_next, gc);
@ -1270,6 +1260,8 @@ mark_comp_env {
gcMARK2(e->prefix, gc);
gcMARK2(e->next, gc);
gcMARK2(e->scopes, gc);
gcMARK2(e->value_name, gc);
gcMARK2(e->observer, gc);
gcMARK2(e->binders, gc);
gcMARK2(e->bindings, gc);
gcMARK2(e->vals, gc);
@ -1429,17 +1421,6 @@ END optimize;
START eval;
mark_comp_info {
mark:
Scheme_Compile_Info *i = (Scheme_Compile_Info *)p;
gcMARK2(i->value_name, gc);
gcMARK2(i->observer, gc);
size:
gcBYTES_TO_WORDS(sizeof(Scheme_Compile_Info));
}
mark_saved_stack {
mark:
Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;

47
racket/src/racket/src/read.c
View File

@ -183,8 +183,6 @@ typedef struct ReadParams {
} ReadParams;
#define THREAD_FOR_LOCALS scheme_current_thread
#define local_list_stack (THREAD_FOR_LOCALS->list_stack)
#define local_list_stack_pos (THREAD_FOR_LOCALS->list_stack_pos)
static Scheme_Object *read_list(Scheme_Object *port, Scheme_Object *stxsrc,
intptr_t line, intptr_t col, intptr_t pos,
@ -560,51 +558,6 @@ void scheme_init_variable_references_constants()
}
static Scheme_Simple_Object *malloc_list_stack()
{
#ifdef MZ_PRECISE_GC
intptr_t sz = sizeof(Scheme_Simple_Object) * NUM_CELLS_PER_STACK;
Scheme_Simple_Object *r;
if (sz < GC_malloc_stays_put_threshold()) {
sz = GC_malloc_stays_put_threshold();
while (sz % sizeof(Scheme_Simple_Object)) {
sz++;
}
}
r = (Scheme_Simple_Object *)GC_malloc_array_tagged(sz);
/* Must set the tag on the first element: */
r[0].iso.so.type = scheme_pair_type;
return r;
#else
return MALLOC_N_RT(Scheme_Simple_Object, NUM_CELLS_PER_STACK);
#endif
}
void scheme_alloc_list_stack(Scheme_Thread *p)
{
Scheme_Simple_Object *sa;
p->list_stack_pos = 0;
sa = malloc_list_stack();
p->list_stack = sa;
}
void scheme_clean_list_stack(Scheme_Thread *p)
{
if (p->list_stack) {
memset(p->list_stack + p->list_stack_pos, 0,
(NUM_CELLS_PER_STACK - p->list_stack_pos) * sizeof(Scheme_Simple_Object));
#ifdef MZ_PRECISE_GC
if (!p->list_stack_pos) {
/* Must set the tag on the first element: */
p->list_stack[0].iso.so.type = scheme_pair_type;
}
#endif
}
}
static void track_indentation(Scheme_Object *indentation, int line, int col)
{
if (!SCHEME_NULLP(indentation)) {

1
racket/src/racket/src/schemef.h
View File

@ -412,7 +412,6 @@ MZ_EXTERN void *GC_malloc_atomic(size_t size_in_bytes);
MZ_EXTERN void *GC_malloc_one_tagged(size_t size_in_bytes);
MZ_EXTERN void *GC_malloc_atomic_uncollectable(size_t size_in_bytes);
MZ_EXTERN void *scheme_malloc_uncollectable(size_t size_in_bytes);
MZ_EXTERN void *GC_malloc_array_tagged(size_t size_in_bytes);
MZ_EXTERN void *GC_malloc_allow_interior(size_t size_in_bytes);
MZ_EXTERN void *GC_malloc_atomic_allow_interior(size_t size_in_bytes);
MZ_EXTERN void *GC_malloc_tagged_allow_interior(size_t size_in_bytes);

1
racket/src/racket/src/schemex.h
View File

@ -320,7 +320,6 @@ void *(*GC_malloc_atomic)(size_t size_in_bytes);
void *(*GC_malloc_one_tagged)(size_t size_in_bytes);
void *(*GC_malloc_atomic_uncollectable)(size_t size_in_bytes);
void *(*scheme_malloc_uncollectable)(size_t size_in_bytes);
void *(*GC_malloc_array_tagged)(size_t size_in_bytes);
void *(*GC_malloc_allow_interior)(size_t size_in_bytes);
void *(*GC_malloc_atomic_allow_interior)(size_t size_in_bytes);
void *(*GC_malloc_tagged_allow_interior)(size_t size_in_bytes);

1
racket/src/racket/src/schemex.inc
View File

@ -223,7 +223,6 @@
scheme_extension_table->GC_malloc_one_tagged = GC_malloc_one_tagged;
scheme_extension_table->GC_malloc_atomic_uncollectable = GC_malloc_atomic_uncollectable;
scheme_extension_table->scheme_malloc_uncollectable = scheme_malloc_uncollectable;
scheme_extension_table->GC_malloc_array_tagged = GC_malloc_array_tagged;
scheme_extension_table->GC_malloc_allow_interior = GC_malloc_allow_interior;
scheme_extension_table->GC_malloc_atomic_allow_interior = GC_malloc_atomic_allow_interior;
scheme_extension_table->GC_malloc_tagged_allow_interior = GC_malloc_tagged_allow_interior;

1
racket/src/racket/src/schemexm.h
View File

@ -223,7 +223,6 @@
#define GC_malloc_one_tagged (scheme_extension_table->GC_malloc_one_tagged)
#define GC_malloc_atomic_uncollectable (scheme_extension_table->GC_malloc_atomic_uncollectable)
#define scheme_malloc_uncollectable (scheme_extension_table->scheme_malloc_uncollectable)
#define GC_malloc_array_tagged (scheme_extension_table->GC_malloc_array_tagged)
#define GC_malloc_allow_interior (scheme_extension_table->GC_malloc_allow_interior)
#define GC_malloc_atomic_allow_interior (scheme_extension_table->GC_malloc_atomic_allow_interior)
#define GC_malloc_tagged_allow_interior (scheme_extension_table->GC_malloc_tagged_allow_interior)

13
racket/src/racket/src/schpriv.h
View File

@ -112,7 +112,6 @@ extern XFORM_NONGCING int scheme_intern_prim_opt_flags(int);
#ifdef MZTAG_REQUIRED
# define scheme_malloc_rt(x) scheme_malloc_tagged(x)
# define MALLOC_ONE_RT(x) MALLOC_ONE_TAGGED(x)
# define MALLOC_N_RT(x,c) MALLOC_N_TAGGED(x,c)
# define MALLOC_ONE_WEAK(x) _MALLOC_N(x, 1, scheme_malloc)
# define MALLOC_N_WEAK(x,c) _MALLOC_N(x, c, scheme_malloc)
# define MALLOC_ONE_TAGGED_WEAK(x) _MALLOC_N(x, 1, scheme_malloc_tagged)
@ -120,7 +119,6 @@ extern XFORM_NONGCING int scheme_intern_prim_opt_flags(int);
#else
# define scheme_malloc_rt(x) scheme_malloc(x)
# define MALLOC_ONE_RT(x) MALLOC_ONE(x)
# define MALLOC_N_RT(x,c) MALLOC_N(x,c)
# define MALLOC_ONE_WEAK(x) MALLOC_ONE_ATOMIC(x)
# define MALLOC_N_WEAK(x,c) MALLOC_N_ATOMIC(x,c)
# define MALLOC_ONE_WEAK_RT(x) MALLOC_ONE_WEAK(x)
@ -2574,6 +2572,9 @@ typedef struct Scheme_Comp_Env
Scheme_Object *scopes; /* can be NULL, a scope, a scope set, or (cons scope-set nobind-scope) */
Scheme_Object *value_name; /* propagated down */
Scheme_Object *observer; /* parameter's value (to avoid looking up every time) */
/* local bindings; */
mzshort num_bindings; /* number of `values' slots */
Scheme_Object **binders; /* identifiers */
@ -2618,11 +2619,9 @@ typedef struct Scheme_Comp_Env
typedef struct Scheme_Compile_Expand_Info
{
MZTAG_IF_REQUIRED
/* allocated as atomic */
short comp;
short comp_flags;
Scheme_Object *value_name;
Scheme_Object *observer;
char dont_mark_local_use;
char resolve_module_ids;
char pre_unwrapped;
@ -2970,7 +2969,7 @@ void scheme_merge_undefineds(Scheme_Comp_Env *exp_env, Scheme_Comp_Env *env);
void scheme_bind_syntaxes(const char *where, Scheme_Object *names, Scheme_Object *a,
Scheme_Env *exp_env, Scheme_Object *insp,
Scheme_Compile_Expand_Info *rec, int drec,
Scheme_Compile_Expand_Info *rec, int drec, Scheme_Object *observer,
Scheme_Comp_Env *stx_env, Scheme_Comp_Env *rhs_env,
int *_pos, Scheme_Object *rename_rib, int replace_value);
int scheme_is_sub_env(Scheme_Comp_Env *stx_env, Scheme_Comp_Env *env);
@ -3130,7 +3129,7 @@ void *scheme_module_run_finish(Scheme_Env *menv, Scheme_Env *env);
void *scheme_module_exprun_finish(Scheme_Env *menv, int set_ns);
void *scheme_module_start_finish(struct Start_Module_Args *a);
Scheme_Object *scheme_build_closure_name(Scheme_Object *code, Scheme_Compile_Info *rec, int drec);
Scheme_Object *scheme_build_closure_name(Scheme_Object *code, Scheme_Comp_Env *env);
#define SCHEME_SYNTAX(obj) SCHEME_PTR1_VAL(obj)
#define SCHEME_SYNTAX_EXP(obj) SCHEME_PTR2_VAL(obj)

133
racket/src/racket/src/stypes.h
View File

@ -233,74 +233,73 @@ enum {
scheme_rt_resolve_info, /* 205 */
scheme_rt_unresolve_info, /* 206 */
scheme_rt_optimize_info, /* 207 */
scheme_rt_compile_info, /* 208 */
scheme_rt_cont_mark, /* 209 */
scheme_rt_saved_stack, /* 210 */
scheme_rt_reply_item, /* 211 */
scheme_rt_closure_info, /* 212 */
scheme_rt_overflow, /* 213 */
scheme_rt_overflow_jmp, /* 214 */
scheme_rt_meta_cont, /* 215 */
scheme_rt_dyn_wind_cell, /* 216 */
scheme_rt_dyn_wind_info, /* 217 */
scheme_rt_dyn_wind, /* 218 */
scheme_rt_dup_check, /* 219 */
scheme_rt_thread_memory, /* 220 */
scheme_rt_input_file, /* 221 */
scheme_rt_input_fd, /* 222 */
scheme_rt_oskit_console_input, /* 223 */
scheme_rt_tested_input_file, /* 224 */
scheme_rt_tested_output_file, /* 225 */
scheme_rt_indexed_string, /* 226 */
scheme_rt_output_file, /* 227 */
scheme_rt_load_handler_data, /* 228 */
scheme_rt_pipe, /* 229 */
scheme_rt_beos_process, /* 230 */
scheme_rt_system_child, /* 231 */
scheme_rt_tcp, /* 232 */
scheme_rt_write_data, /* 233 */
scheme_rt_tcp_select_info, /* 234 */
scheme_rt_param_data, /* 235 */
scheme_rt_will, /* 236 */
scheme_rt_linker_name, /* 237 */
scheme_rt_param_map, /* 238 */
scheme_rt_finalization, /* 239 */
scheme_rt_finalizations, /* 240 */
scheme_rt_cpp_object, /* 241 */
scheme_rt_cpp_array_object, /* 242 */
scheme_rt_stack_object, /* 243 */
scheme_rt_preallocated_object, /* 244 */
scheme_thread_hop_type, /* 245 */
scheme_rt_srcloc, /* 246 */
scheme_rt_evt, /* 247 */
scheme_rt_syncing, /* 248 */
scheme_rt_comp_prefix, /* 249 */
scheme_rt_user_input, /* 250 */
scheme_rt_user_output, /* 251 */
scheme_rt_compact_port, /* 252 */
scheme_rt_read_special_dw, /* 253 */
scheme_rt_regwork, /* 254 */
scheme_rt_rx_lazy_string, /* 255 */
scheme_rt_buf_holder, /* 256 */
scheme_rt_parameterization, /* 257 */
scheme_rt_print_params, /* 258 */
scheme_rt_read_params, /* 259 */
scheme_rt_native_code, /* 260 */
scheme_rt_native_code_plus_case, /* 261 */
scheme_rt_jitter_data, /* 262 */
scheme_rt_module_exports, /* 263 */
scheme_rt_delay_load_info, /* 264 */
scheme_rt_marshal_info, /* 265 */
scheme_rt_unmarshal_info, /* 266 */
scheme_rt_runstack, /* 267 */
scheme_rt_sfs_info, /* 268 */
scheme_rt_validate_clearing, /* 269 */
scheme_rt_lightweight_cont, /* 270 */
scheme_rt_export_info, /* 271 */
scheme_rt_cont_jmp, /* 272 */
scheme_rt_letrec_check_frame, /* 273 */
scheme_rt_cont_mark, /* 208 */
scheme_rt_saved_stack, /* 209 */
scheme_rt_reply_item, /* 210 */
scheme_rt_closure_info, /* 211 */
scheme_rt_overflow, /* 212 */
scheme_rt_overflow_jmp, /* 213 */
scheme_rt_meta_cont, /* 214 */
scheme_rt_dyn_wind_cell, /* 215 */
scheme_rt_dyn_wind_info, /* 216 */
scheme_rt_dyn_wind, /* 217 */
scheme_rt_dup_check, /* 218 */
scheme_rt_thread_memory, /* 219 */
scheme_rt_input_file, /* 220 */
scheme_rt_input_fd, /* 221 */
scheme_rt_oskit_console_input, /* 222 */
scheme_rt_tested_input_file, /* 223 */
scheme_rt_tested_output_file, /* 224 */
scheme_rt_indexed_string, /* 225 */
scheme_rt_output_file, /* 226 */
scheme_rt_load_handler_data, /* 227 */
scheme_rt_pipe, /* 228 */
scheme_rt_beos_process, /* 229 */
scheme_rt_system_child, /* 230 */
scheme_rt_tcp, /* 231 */
scheme_rt_write_data, /* 232 */
scheme_rt_tcp_select_info, /* 233 */
scheme_rt_param_data, /* 234 */
scheme_rt_will, /* 235 */
scheme_rt_linker_name, /* 236 */
scheme_rt_param_map, /* 237 */
scheme_rt_finalization, /* 238 */
scheme_rt_finalizations, /* 239 */
scheme_rt_cpp_object, /* 240 */
scheme_rt_cpp_array_object, /* 241 */
scheme_rt_stack_object, /* 242 */
scheme_rt_preallocated_object, /* 243 */
scheme_thread_hop_type, /* 244 */
scheme_rt_srcloc, /* 245 */
scheme_rt_evt, /* 246 */
scheme_rt_syncing, /* 247 */
scheme_rt_comp_prefix, /* 248 */
scheme_rt_user_input, /* 249 */
scheme_rt_user_output, /* 250 */
scheme_rt_compact_port, /* 251 */
scheme_rt_read_special_dw, /* 252 */
scheme_rt_regwork, /* 253 */
scheme_rt_rx_lazy_string, /* 254 */
scheme_rt_buf_holder, /* 255 */
scheme_rt_parameterization, /* 256 */
scheme_rt_print_params, /* 257 */
scheme_rt_read_params, /* 258 */
scheme_rt_native_code, /* 259 */
scheme_rt_native_code_plus_case, /* 260 */
scheme_rt_jitter_data, /* 261 */
scheme_rt_module_exports, /* 262 */
scheme_rt_delay_load_info, /* 263 */
scheme_rt_marshal_info, /* 264 */
scheme_rt_unmarshal_info, /* 265 */
scheme_rt_runstack, /* 266 */
scheme_rt_sfs_info, /* 267 */
scheme_rt_validate_clearing, /* 268 */
scheme_rt_lightweight_cont, /* 269 */
scheme_rt_export_info, /* 270 */
scheme_rt_cont_jmp, /* 271 */
scheme_rt_letrec_check_frame, /* 272 */
#endif
scheme_deferred_expr_type, /* 274 */
scheme_deferred_expr_type, /* 273 */
_scheme_last_type_
};

15
racket/src/racket/src/thread.c
View File

@ -2413,8 +2413,6 @@ static Scheme_Thread *make_thread(Scheme_Config *config,
process->ran_some = 1;
process->list_stack = NULL;
scheme_gmp_tls_init(process->gmp_tls);
if (prefix) {
@ -2946,8 +2944,6 @@ static void thread_is_dead(Scheme_Thread *r)
r->suspended_box = NULL;
r->resumed_box = NULL;
r->list_stack = NULL;
r->t_set_parent = NULL;
r->dw = NULL;
r->init_config = NULL;
@ -3049,11 +3045,6 @@ static void remove_thread(Scheme_Thread *r)
r->ku.multiple.array = NULL;
r->values_buffer = NULL;
#ifndef SENORA_GC_NO_FREE
if (r->list_stack)
GC_free(r->list_stack);
#endif
thread_is_dead(r);
/* In case we kill a thread while in a bignum operation: */
@ -3530,9 +3521,6 @@ Scheme_Object *scheme_call_as_nested_thread(int argc, Scheme_Object *argv[], voi
}
np->tail_buffer_size = p->tail_buffer_size;
np->list_stack = p->list_stack;
np->list_stack_pos = p->list_stack_pos;
scheme_gmp_tls_init(np->gmp_tls);
/* np->prev = NULL; - 0ed by allocation */
@ -9018,9 +9006,6 @@ static void prepare_thread_for_GC(Scheme_Object *t)
}
p->spare_runstack = NULL;
/* zero ununsed part of list stack */
scheme_clean_list_stack(p);
}
void scheme_prepare_this_thread_for_GC(Scheme_Thread *p)