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

split up mzmark output

Browse Source
This commit is contained in:
Matthew Flatt 2011-05-07 06:49:57 -06:00
parent 01193652b0
commit 09046b46dd
58 changed files with 5922 additions and 6138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/racket/Makefile.in
View File

@ -219,9 +219,6 @@ total_startup:
mv src/schminc.newh src/schminc.h
$(MAKE) cgc
mark:
$(MAKE) $(srcdir)/src/mzmark.c
headers:
./racket@CGC@ -cqu $(srcdir)/mkincludes.rkt "$(DESTDIR)$(includepltdir)" "$(srcdir)" .
@ -234,8 +231,9 @@ $(srcdir)/src/$(STARTUPDEST): $(srcdir)/src/startup.rktl $(srcdir)/src/sstoinct.
racket -cu $(srcdir)/src/sstoinct.rkt < $(srcdir)/src/startup.rktl > $(srcdir)/src/$(STARTUPDEST)
$(srcdir)/src/$(CSTARTUPDEST): $(srcdir)/src/startup.rktl $(srcdir)/src/schvers.h $(srcdir)/src/schminc.h
./racketcgc -cu $(srcdir)/src/sstoinc.rkt $(CSTARTUPEXTRA) $(srcdir)/src/$(CSTARTUPDEST) < $(srcdir)/src/startup.rktl
$(srcdir)/src/mzmark.c: $(srcdir)/src/mzmarksrc.c $(srcdir)/src/mkmark.rkt
racket -cu $(srcdir)/src/mkmark.rkt < $(srcdir)/src/mzmarksrc.c > $(srcdir)/src/mzmark.c
mark:
racket -cu $(srcdir)/src/mkmark.rkt $(srcdir)/src < $(srcdir)/src/mzmarksrc.c
cstartup.zo:
$(MAKE) startup CSTARTUPEXTRA='zo' CSTARTUPDEST="../cstartup.zo"

58
src/racket/src/Makefile.in
View File

@ -294,7 +294,7 @@ SCONFIG = $(srcdir)/../sconfig.h $(srcdir)/../uconfig.h ../mzconfig.h
COMMON_HEADERS = $(srcdir)/schpriv.h $(srcdir)/schexn.h $(SCONFIG) $(srcdir)/../include/scheme.h \
$(srcdir)/../include/schthread.h
JIT_HEADERS = $(srcdir)/../src/jit.h \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c \
$(srcdir)/../src/stypes.h \
$(srcdir)/lightning/i386/core.h $(srcdir)/lightning/i386/core-common.h \
$(srcdir)/lightning/i386/asm.h $(srcdir)/lightning/i386/asm-common.h \
$(srcdir)/lightning/i386/funcs.h $(srcdir)/lightning/i386/funcs-common.h \
@ -306,7 +306,7 @@ JIT_HEADERS = $(srcdir)/../src/jit.h \
$(srcdir)/future.h $(srcdir)/jit_ts.c $(srcdir)/jit_ts_protos.h
salloc.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../gc/gc.h $(srcdir)/mzmark.c
$(srcdir)/../gc/gc.h $(srcdir)/mzmark_salloc.inc
bignum.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
bool.@LTO@: $(COMMON_HEADERS) \
@ -316,33 +316,33 @@ builtin.@LTO@: $(COMMON_HEADERS) \
char.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schuchar.inc
compenv.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_compenv.inc
compile.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_compile.inc
complex.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
dynext.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/../src/schemex.h \
$(srcdir)/schvers.h $(srcdir)/../gc/gc.h $(srcdir)/schemex.h
env.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schminc.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schminc.h $(srcdir)/mzmark_env.inc
error.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
eval.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_eval.inc \
$(srcdir)/schmach.h $(srcdir)/mzstkchk.h $(srcdir)/schrunst.h \
$(srcdir)/future.h
file.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h
fun.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c $(srcdir)/schmap.inc \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_fun.inc $(srcdir)/schmap.inc \
$(srcdir)/future.h
future.@LTO@: $(COMMON_HEADERS) $(srcdir)/future.h $(SCONFIG) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c $(srcdir)/mzrt.h \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_future.inc $(srcdir)/mzrt.h \
$(srcdir)/jit_ts_future_glue.c $(srcdir)/jit_ts_runtime_glue.c $(srcdir)/jit_ts_protos.h
hash.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
jit.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_hash.inc
jit.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS) $(srcdir)/mzmark_jit.inc
jitalloc.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
jitarith.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
jitcall.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
@ -357,10 +357,10 @@ list.@LTO@: $(COMMON_HEADERS) \
marshal.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
module.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h
mzrt.@LTO@: $(COMMON_HEADERS)
network.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_network.inc
numarith.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/nummacs.h
number.@LTO@: $(COMMON_HEADERS) \
@ -370,44 +370,44 @@ numcomp.@LTO@: $(COMMON_HEADERS) \
numstr.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/random.inc $(srcdir)/newrandom.inc
optimize.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_optimize.inc
place.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_place.inc
port.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_port.inc
portfun.@LTO@: $(COMMON_HEADERS) $(srcdir)/schvers.h \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_portfun.inc
print.@LTO@: $(COMMON_HEADERS) $(srcdir)/../src/stypes.h $(srcdir)/../src/schcpt.h \
$(srcdir)/schvers.h $(SCONFIG) $(srcdir)/mzmark.c
$(srcdir)/schvers.h $(SCONFIG) $(srcdir)/mzmark_print.inc
thread.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_thread.inc
rational.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
read.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/schcpt.h $(srcdir)/schvers.h $(srcdir)/schminc.h \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_read.inc
regexp.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c $(srcdir)/schrx.h
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_regexp.inc $(srcdir)/schrx.h
resolve.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_resolve.inc
setjmpup.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schmach.h
sfs.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_sfs.inc
string.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schvers.h $(srcdir)/mzmark.c $(srcdir)/strops.inc \
$(srcdir)/../src/stypes.h $(srcdir)/schvers.h $(srcdir)/mzmark_string.inc $(srcdir)/strops.inc \
$(srcdir)/schustr.inc
struct.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_struct.inc
syntax.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_syntax.inc
symbol.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
sema.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_sema.inc
type.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h $(srcdir)/mzmark.c
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_type.inc
vector.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
vadliate.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/../src/stypes.h
$(srcdir)/../src/stypes.h $(srcdir)/mzmark_validate.inc

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

@ -2449,8 +2449,7 @@ void scheme_dup_symbol_check(DupCheckRecord *r, const char *where,
START_XFORM_SKIP;
#define MARKS_FOR_COMPENV_C
#include "mzmark.c"
#include "mzmark_compenv.inc"
static void register_traversers(void)
{

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

@ -5434,8 +5434,7 @@ void scheme_add_core_stop_form(int pos, Scheme_Object *sym, Scheme_Comp_Env *env
START_XFORM_SKIP;
#define MARKS_FOR_COMPILE_C
#include "mzmark.c"
#include "mzmark_compile.inc"
static void register_traversers(void)
{

3
src/racket/src/env.c
View File

@ -2531,8 +2531,7 @@ rename_transformer_p(int argc, Scheme_Object *argv[])
START_XFORM_SKIP;
#define MARKS_FOR_ENV_C
#include "mzmark.c"
#include "mzmark_env.inc"
static void register_traversers(void)
{

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

@ -5342,8 +5342,7 @@ static void mark_pruned_prefixes(struct NewGC *gc) XFORM_SKIP_PROC
START_XFORM_SKIP;
#define MARKS_FOR_EVAL_C
#include "mzmark.c"
#include "mzmark_eval.inc"
static void register_traversers(void)
{

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

@ -8556,8 +8556,7 @@ scheme_default_read_handler(int argc, Scheme_Object *argv[])
START_XFORM_SKIP;
#define MARKS_FOR_FUN_C
#include "mzmark.c"
#include "mzmark_fun.inc"
static void register_traversers(void)
{

3
src/racket/src/future.c
View File

@ -3043,8 +3043,7 @@ future_t *get_pending_future(Scheme_Future_State *fs)
START_XFORM_SKIP;
#define MARKS_FOR_FUTURE_C
#include "mzmark.c"
#include "mzmark_future.inc"
static void register_traversers(void)
{

3
src/racket/src/hash.c
View File

@ -2566,8 +2566,7 @@ int scheme_hash_tree_equal(Scheme_Hash_Tree *t1, Scheme_Hash_Tree *t2)
START_XFORM_SKIP;
#define MARKS_FOR_HASH_C
#include "mzmark.c"
#include "mzmark_hash.inc"
static void register_traversers(void)
{

3
src/racket/src/jit.c
View File

@ -3794,8 +3794,7 @@ void scheme_jit_fill_threadlocal_table() {
START_XFORM_SKIP;
#define MARKS_FOR_JIT_C
#include "mzmark.c"
#include "mzmark_jit.inc"
void scheme_jit_register_traversers(void)
{

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

@ -13,9 +13,6 @@
(define re:const-size (regexp "^[ \t]*gcBYTES_TO_WORDS[(]sizeof[(][A-Za-z0-9_]*[)][)];[ \t]*$"))
(define (upcase s)
(list->string (map char-upcase (string->list s))))
(define (do-form name)
(let ([read-lines
(lambda (re:done)
@ -108,31 +105,50 @@
"1"
"0")))))
(printf "/* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */\n")
(let loop ()
(let ([l (read-line)])
(unless (eof-object? l)
(cond
[(regexp-match re:start l)
=> (lambda (m)
(let ([who (upcase (cadr m))])
(printf "#ifdef MARKS_FOR_~a_C\n" who)
(let file-loop ()
(let ([l (read-line)])
(if (eof-object? l)
(error 'mkmark.rkt "unexpected EOF")
(cond
[(regexp-match re:end l)
=> (lambda (m)
(printf "#endif /* ~a */\n" (upcase (cadr m)))
(loop))]
[(regexp-match re:form l)
=> (lambda (m)
(do-form (cadr m))
(file-loop))]
[else (printf "~a\n" l)
(file-loop)]))))))]
[else (printf "~a\n" l)
(loop)]))))
(let ([who (cadr m)]
[so (open-output-bytes)])
(parameterize ([current-output-port so])
(printf "/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */\n")
(let file-loop ()
(let ([l (read-line)])
(if (eof-object? l)
(error 'mkmark.rkt "unexpected EOF")
(cond
[(regexp-match re:end l)
=> (lambda (m) (void))]
[(regexp-match re:form l)
=> (lambda (m)
(do-form (cadr m))
(file-loop))]
[else (printf "~a\n" l)
(file-loop)])))))
(let* ([b (get-output-bytes so)]
[file (build-path
(vector-ref (current-command-line-arguments) 0)
(format "mzmark_~a.inc" who))]
[so2 (open-output-bytes)])
(when (file-exists? file)
(call-with-input-file*
file
(lambda (i)
(let loop ()
(let ([s (read-bytes 4096 i)])
(unless (eof-object? s)
(write-bytes s so2)
(loop)))))))
(let ([b2 (get-output-bytes so2)])
(unless (equal? b b2)
(printf "Writing ~a\n" file)
(call-with-output-file*
file
#:exists 'truncate/replace
(lambda (o)
(write-bytes b o)))))))
(loop))]
[else (loop)]))))

5985
src/racket/src/mzmark.c
View File

File diff suppressed because it is too large Load Diff

67
src/racket/src/mzmark_compenv.inc Normal file
View File

@ -0,0 +1,67 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_comp_env_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
}
static int mark_comp_env_MARK(void *p, struct NewGC *gc) {
Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p;
gcMARK2(e->base.genv, gc);
gcMARK2(e->base.insp, gc);
gcMARK2(e->base.prefix, gc);
gcMARK2(e->base.next, gc);
gcMARK2(e->base.values, gc);
gcMARK2(e->base.certs, gc);
gcMARK2(e->base.renames, gc);
gcMARK2(e->base.uid, gc);
gcMARK2(e->base.uids, gc);
gcMARK2(e->base.dup_check, gc);
gcMARK2(e->base.intdef_name, gc);
gcMARK2(e->base.in_modidx, gc);
gcMARK2(e->base.skip_table, gc);
gcMARK2(e->data.const_names, gc);
gcMARK2(e->data.const_vals, gc);
gcMARK2(e->data.const_uids, gc);
gcMARK2(e->data.sealed, gc);
gcMARK2(e->data.use, gc);
gcMARK2(e->data.lifts, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
}
static int mark_comp_env_FIXUP(void *p, struct NewGC *gc) {
Scheme_Full_Comp_Env *e = (Scheme_Full_Comp_Env *)p;
gcFIXUP2(e->base.genv, gc);
gcFIXUP2(e->base.insp, gc);
gcFIXUP2(e->base.prefix, gc);
gcFIXUP2(e->base.next, gc);
gcFIXUP2(e->base.values, gc);
gcFIXUP2(e->base.certs, gc);
gcFIXUP2(e->base.renames, gc);
gcFIXUP2(e->base.uid, gc);
gcFIXUP2(e->base.uids, gc);
gcFIXUP2(e->base.dup_check, gc);
gcFIXUP2(e->base.intdef_name, gc);
gcFIXUP2(e->base.in_modidx, gc);
gcFIXUP2(e->base.skip_table, gc);
gcFIXUP2(e->data.const_names, gc);
gcFIXUP2(e->data.const_vals, gc);
gcFIXUP2(e->data.const_uids, gc);
gcFIXUP2(e->data.sealed, gc);
gcFIXUP2(e->data.use, gc);
gcFIXUP2(e->data.lifts, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Full_Comp_Env));
}
#define mark_comp_env_IS_ATOMIC 0
#define mark_comp_env_IS_CONST_SIZE 1

2
src/racket/src/mzmark_compile.inc Normal file
View File

@ -0,0 +1,2 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */

2
src/racket/src/mzmark_env.inc Normal file
View File

@ -0,0 +1,2 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */

62
src/racket/src/mzmark_eval.inc Normal file
View File

@ -0,0 +1,62 @@
/* >>>> Generated by mkmarak.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->certs, 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->certs, 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
gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
}
static int mark_saved_stack_MARK(void *p, struct NewGC *gc) {
Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
gcMARK2(saved->prev, gc);
gcMARK2(saved->runstack_start, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
}
static int mark_saved_stack_FIXUP(void *p, struct NewGC *gc) {
Scheme_Saved_Stack *saved = (Scheme_Saved_Stack *)p;
gcFIXUP2(saved->prev, gc);
gcFIXUP2(saved->runstack_start, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Saved_Stack));
}
#define mark_saved_stack_IS_ATOMIC 0
#define mark_saved_stack_IS_CONST_SIZE 1

161
src/racket/src/mzmark_fun.inc Normal file
View File

@ -0,0 +1,161 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_closure_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Closure_Info));
}
static int mark_closure_info_MARK(void *p, struct NewGC *gc) {
Closure_Info *i = (Closure_Info *)p;
gcMARK2(i->local_flags, gc);
gcMARK2(i->base_closure_map, gc);
gcMARK2(i->flonum_map, gc);
return
gcBYTES_TO_WORDS(sizeof(Closure_Info));
}
static int mark_closure_info_FIXUP(void *p, struct NewGC *gc) {
Closure_Info *i = (Closure_Info *)p;
gcFIXUP2(i->local_flags, gc);
gcFIXUP2(i->base_closure_map, gc);
gcFIXUP2(i->flonum_map, gc);
return
gcBYTES_TO_WORDS(sizeof(Closure_Info));
}
#define mark_closure_info_IS_ATOMIC 0
#define mark_closure_info_IS_CONST_SIZE 1
static int mark_dyn_wind_cell_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
}
static int mark_dyn_wind_cell_MARK(void *p, struct NewGC *gc) {
Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
gcMARK2(l->dw, gc);
gcMARK2(l->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
}
static int mark_dyn_wind_cell_FIXUP(void *p, struct NewGC *gc) {
Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p;
gcFIXUP2(l->dw, gc);
gcFIXUP2(l->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List));
}
#define mark_dyn_wind_cell_IS_ATOMIC 0
#define mark_dyn_wind_cell_IS_CONST_SIZE 1
static int mark_dyn_wind_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
}
static int mark_dyn_wind_info_MARK(void *p, struct NewGC *gc) {
Dyn_Wind *d = (Dyn_Wind *)p;
gcMARK2(d->pre, gc);
gcMARK2(d->act, gc);
gcMARK2(d->post, gc);
return
gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
}
static int mark_dyn_wind_info_FIXUP(void *p, struct NewGC *gc) {
Dyn_Wind *d = (Dyn_Wind *)p;
gcFIXUP2(d->pre, gc);
gcFIXUP2(d->act, gc);
gcFIXUP2(d->post, gc);
return
gcBYTES_TO_WORDS(sizeof(Dyn_Wind));
}
#define mark_dyn_wind_info_IS_ATOMIC 0
#define mark_dyn_wind_info_IS_CONST_SIZE 1
static int mark_cont_mark_chain_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
}
static int mark_cont_mark_chain_MARK(void *p, struct NewGC *gc) {
Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
gcMARK2(c->key, gc);
gcMARK2(c->val, gc);
gcMARK2(c->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
}
static int mark_cont_mark_chain_FIXUP(void *p, struct NewGC *gc) {
Scheme_Cont_Mark_Chain *c = (Scheme_Cont_Mark_Chain *)p;
gcFIXUP2(c->key, gc);
gcFIXUP2(c->val, gc);
gcFIXUP2(c->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cont_Mark_Chain));
}
#define mark_cont_mark_chain_IS_ATOMIC 0
#define mark_cont_mark_chain_IS_CONST_SIZE 1
#ifdef MZ_USE_JIT
static int mark_lightweight_cont_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation));
}
static int mark_lightweight_cont_MARK(void *p, struct NewGC *gc) {
Scheme_Lightweight_Continuation *lw = (Scheme_Lightweight_Continuation *)p;
gcMARK2(lw->saved_lwc, gc);
gcMARK2(lw->stack_slice, gc);
gcMARK2(lw->runstack_slice, gc);
gcMARK2(lw->cont_mark_stack_slice, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation));
}
static int mark_lightweight_cont_FIXUP(void *p, struct NewGC *gc) {
Scheme_Lightweight_Continuation *lw = (Scheme_Lightweight_Continuation *)p;
gcFIXUP2(lw->saved_lwc, gc);
gcFIXUP2(lw->stack_slice, gc);
gcFIXUP2(lw->runstack_slice, gc);
gcFIXUP2(lw->cont_mark_stack_slice, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lightweight_Continuation));
}
#define mark_lightweight_cont_IS_ATOMIC 0
#define mark_lightweight_cont_IS_CONST_SIZE 1
#endif

164
src/racket/src/mzmark_future.inc Normal file
View File

@ -0,0 +1,164 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
#ifdef MZ_USE_FUTURES
static int future_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(future_t));
}
static int future_MARK(void *p, struct NewGC *gc) {
future_t *f = (future_t *)p;
gcMARK2(f->orig_lambda, gc);
gcMARK2(f->cust, gc);
gcMARK2(f->arg_s0, gc);
gcMARK2(f->arg_t0, gc);
gcMARK2(f->arg_S0, gc);
gcMARK2(f->arg_b0, gc);
gcMARK2(f->arg_n0, gc);
gcMARK2(f->arg_s1, gc);
gcMARK2(f->arg_t1, gc);
gcMARK2(f->arg_S1, gc);
gcMARK2(f->arg_s2, gc);
gcMARK2(f->arg_S2, gc);
gcMARK2(f->arg_p, gc);
gcMARK2(f->arg_S4, gc);
gcMARK2(f->retval_s, gc);
gcMARK2(f->retval, gc);
gcMARK2(f->multiple_array, gc);
gcMARK2(f->tail_rator, gc);
gcMARK2(f->tail_rands, gc);
gcMARK2(f->prev, gc);
gcMARK2(f->next, gc);
gcMARK2(f->next_waiting_atomic, gc);
gcMARK2(f->next_waiting_lwc, gc);
gcMARK2(f->next_waiting_touch, gc);
gcMARK2(f->suspended_lw, gc);
gcMARK2(f->prev_in_fsema_queue, gc);
gcMARK2(f->next_in_fsema_queue, gc);
gcMARK2(f->touching, gc);
return
gcBYTES_TO_WORDS(sizeof(future_t));
}
static int future_FIXUP(void *p, struct NewGC *gc) {
future_t *f = (future_t *)p;
gcFIXUP2(f->orig_lambda, gc);
gcFIXUP2(f->cust, gc);
gcFIXUP2(f->arg_s0, gc);
gcFIXUP2(f->arg_t0, gc);
gcFIXUP2(f->arg_S0, gc);
gcFIXUP2(f->arg_b0, gc);
gcFIXUP2(f->arg_n0, gc);
gcFIXUP2(f->arg_s1, gc);
gcFIXUP2(f->arg_t1, gc);
gcFIXUP2(f->arg_S1, gc);
gcFIXUP2(f->arg_s2, gc);
gcFIXUP2(f->arg_S2, gc);
gcFIXUP2(f->arg_p, gc);
gcFIXUP2(f->arg_S4, gc);
gcFIXUP2(f->retval_s, gc);
gcFIXUP2(f->retval, gc);
gcFIXUP2(f->multiple_array, gc);
gcFIXUP2(f->tail_rator, gc);
gcFIXUP2(f->tail_rands, gc);
gcFIXUP2(f->prev, gc);
gcFIXUP2(f->next, gc);
gcFIXUP2(f->next_waiting_atomic, gc);
gcFIXUP2(f->next_waiting_lwc, gc);
gcFIXUP2(f->next_waiting_touch, gc);
gcFIXUP2(f->suspended_lw, gc);
gcFIXUP2(f->prev_in_fsema_queue, gc);
gcFIXUP2(f->next_in_fsema_queue, gc);
gcFIXUP2(f->touching, gc);
return
gcBYTES_TO_WORDS(sizeof(future_t));
}
#define future_IS_ATOMIC 0
#define future_IS_CONST_SIZE 1
static int fsemaphore_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
}
static int fsemaphore_MARK(void *p, struct NewGC *gc) {
fsemaphore_t *s = (fsemaphore_t*)p;
gcMARK2(s->queue_front, gc);
gcMARK2(s->queue_end, gc);
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
}
static int fsemaphore_FIXUP(void *p, struct NewGC *gc) {
fsemaphore_t *s = (fsemaphore_t*)p;
gcFIXUP2(s->queue_front, gc);
gcFIXUP2(s->queue_end, gc);
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
}
#define fsemaphore_IS_ATOMIC 0
#define fsemaphore_IS_CONST_SIZE 1
#else
static int sequential_future_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(future_t));
}
static int sequential_future_MARK(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(future_t));
}
static int sequential_future_FIXUP(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(future_t));
}
#define sequential_future_IS_ATOMIC 0
#define sequential_future_IS_CONST_SIZE 1
static int sequential_fsemaphore_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
}
static int sequential_fsemaphore_MARK(void *p, struct NewGC *gc) {
fsemaphore_t *s = (fsemaphore_t*)p;
gcMARK2(s->sema, gc);
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
}
static int sequential_fsemaphore_FIXUP(void *p, struct NewGC *gc) {
fsemaphore_t *s = (fsemaphore_t*)p;
gcFIXUP2(s->sema, gc);
return
gcBYTES_TO_WORDS(sizeof(fsemaphore_t));
}
#define sequential_fsemaphore_IS_ATOMIC 0
#define sequential_fsemaphore_IS_CONST_SIZE 1
#endif

74
src/racket/src/mzmark_hash.inc Normal file
View File

@ -0,0 +1,74 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int hash_tree_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
}
static int hash_tree_val_MARK(void *p, struct NewGC *gc) {
Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
gcMARK2(ht->root, gc);
gcMARK2(ht->elems_box, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
}
static int hash_tree_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Hash_Tree *ht = (Scheme_Hash_Tree *)p;
gcFIXUP2(ht->root, gc);
gcFIXUP2(ht->elems_box, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Hash_Tree));
}
#define hash_tree_val_IS_ATOMIC 0
#define hash_tree_val_IS_CONST_SIZE 1
static int mark_rb_node_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(RBNode));
}
static int mark_rb_node_MARK(void *p, struct NewGC *gc) {
RBNode *rb = (RBNode *)p;
/* Short-circuit on NULL pointers, which are especially likely */
if (rb->left) {
gcMARK2(rb->left, gc);
}
if (rb->right) {
gcMARK2(rb->right, gc);
}
gcMARK2(rb->key, gc);
gcMARK2(rb->val, gc);
return
gcBYTES_TO_WORDS(sizeof(RBNode));
}
static int mark_rb_node_FIXUP(void *p, struct NewGC *gc) {
RBNode *rb = (RBNode *)p;
/* Short-circuit on NULL pointers, which are especially likely */
if (rb->left) {
gcFIXUP2(rb->left, gc);
}
if (rb->right) {
gcFIXUP2(rb->right, gc);
}
gcFIXUP2(rb->key, gc);
gcFIXUP2(rb->val, gc);
return
gcBYTES_TO_WORDS(sizeof(RBNode));
}
#define mark_rb_node_IS_ATOMIC 0
#define mark_rb_node_IS_CONST_SIZE 1

173
src/racket/src/mzmark_jit.inc Normal file
View File

@ -0,0 +1,173 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int native_closure_SIZE(void *p, struct NewGC *gc) {
Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size;
if (closure_size < 0) {
closure_size = -(closure_size + 1);
}
return
gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
+ (closure_size - 1) * sizeof(Scheme_Object *)));
}
static int native_closure_MARK(void *p, struct NewGC *gc) {
Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size;
if (closure_size < 0) {
closure_size = -(closure_size + 1);
}
{
int i = closure_size;
# define CLOSURE_DATA_TYPE Scheme_Native_Closure_Data
# include "mzclpf_decl.inc"
gcMARK2(c->code, gc);
# include "mzclpf_pre.inc"
while (i--)
gcMARK2(c->vals[i], gc);
# include "mzclpf_post.inc"
# undef CLOSURE_DATA_TYPE
}
return
gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
+ (closure_size - 1) * sizeof(Scheme_Object *)));
}
static int native_closure_FIXUP(void *p, struct NewGC *gc) {
Scheme_Native_Closure *c = (Scheme_Native_Closure *)p;
int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size;
if (closure_size < 0) {
closure_size = -(closure_size + 1);
}
{
int i = closure_size;
gcFIXUP2(c->code, gc);
while (i--)
gcFIXUP2(c->vals[i], gc);
}
return
gcBYTES_TO_WORDS((sizeof(Scheme_Native_Closure)
+ (closure_size - 1) * sizeof(Scheme_Object *)));
}
#define native_closure_IS_ATOMIC 0
#define native_closure_IS_CONST_SIZE 0
static int mark_jit_state_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(mz_jit_state));
}
static int mark_jit_state_MARK(void *p, struct NewGC *gc) {
mz_jit_state *j = (mz_jit_state *)p;
gcMARK2(j->mappings, gc);
gcMARK2(j->self_data, gc);
return
gcBYTES_TO_WORDS(sizeof(mz_jit_state));
}
static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) {
mz_jit_state *j = (mz_jit_state *)p;
gcFIXUP2(j->mappings, gc);
gcFIXUP2(j->self_data, gc);
return
gcBYTES_TO_WORDS(sizeof(mz_jit_state));
}
#define mark_jit_state_IS_ATOMIC 0
#define mark_jit_state_IS_CONST_SIZE 1
static int native_unclosed_proc_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
}
static int native_unclosed_proc_MARK(void *p, struct NewGC *gc) {
Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
int i;
gcMARK2(d->u2.name, gc);
if (d->retained) {
for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) {
gcMARK2(d->retained[i], gc);
}
}
if (d->closure_size < 0) {
gcMARK2(d->u.arities, gc);
}
gcMARK2(d->tl_map, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
}
static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) {
Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p;
int i;
gcFIXUP2(d->u2.name, gc);
if (d->retained) {
for (i = SCHEME_INT_VAL(d->retained[0]); i--; ) {
gcFIXUP2(d->retained[i], gc);
}
}
if (d->closure_size < 0) {
gcFIXUP2(d->u.arities, gc);
}
gcFIXUP2(d->tl_map, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data));
}
#define native_unclosed_proc_IS_ATOMIC 0
#define native_unclosed_proc_IS_CONST_SIZE 1
static int native_unclosed_proc_plus_case_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
}
static int native_unclosed_proc_plus_case_MARK(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
}
static int native_unclosed_proc_plus_case_FIXUP(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case));
}
#define native_unclosed_proc_plus_case_IS_ATOMIC 0
#define native_unclosed_proc_plus_case_IS_CONST_SIZE 1

126
src/racket/src/mzmark_network.inc Normal file
View File

@ -0,0 +1,126 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_listener_SIZE(void *p, struct NewGC *gc) {
listener_t *l = (listener_t *)p;
return
gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
}
static int mark_listener_MARK(void *p, struct NewGC *gc) {
listener_t *l = (listener_t *)p;
gcMARK2(l->mref, gc);
return
gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
}
static int mark_listener_FIXUP(void *p, struct NewGC *gc) {
listener_t *l = (listener_t *)p;
gcFIXUP2(l->mref, gc);
return
gcBYTES_TO_WORDS(sizeof(listener_t) + ((l->count - 1) * sizeof(tcp_t)));
}
#define mark_listener_IS_ATOMIC 0
#define mark_listener_IS_CONST_SIZE 0
#ifdef USE_TCP
static int mark_tcp_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
}
static int mark_tcp_MARK(void *p, struct NewGC *gc) {
Scheme_Tcp *tcp = (Scheme_Tcp *)p;
gcMARK2(tcp->b.buffer, gc);
gcMARK2(tcp->b.out_buffer, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
}
static int mark_tcp_FIXUP(void *p, struct NewGC *gc) {
Scheme_Tcp *tcp = (Scheme_Tcp *)p;
gcFIXUP2(tcp->b.buffer, gc);
gcFIXUP2(tcp->b.out_buffer, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Tcp));
}
#define mark_tcp_IS_ATOMIC 0
#define mark_tcp_IS_CONST_SIZE 1
# ifdef UDP_IS_SUPPORTED
static int mark_udp_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
}
static int mark_udp_MARK(void *p, struct NewGC *gc) {
Scheme_UDP *udp = (Scheme_UDP *)p;
gcMARK2(udp->previous_from_addr, gc);
gcMARK2(udp->mref, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
}
static int mark_udp_FIXUP(void *p, struct NewGC *gc) {
Scheme_UDP *udp = (Scheme_UDP *)p;
gcFIXUP2(udp->previous_from_addr, gc);
gcFIXUP2(udp->mref, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP));
}
#define mark_udp_IS_ATOMIC 0
#define mark_udp_IS_CONST_SIZE 1
static int mark_udp_evt_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
}
static int mark_udp_evt_MARK(void *p, struct NewGC *gc) {
Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
gcMARK2(uw->udp, gc);
gcMARK2(uw->str, gc);
gcMARK2(uw->dest_addr, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
}
static int mark_udp_evt_FIXUP(void *p, struct NewGC *gc) {
Scheme_UDP_Evt *uw = (Scheme_UDP_Evt *)p;
gcFIXUP2(uw->udp, gc);
gcFIXUP2(uw->str, gc);
gcFIXUP2(uw->dest_addr, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_UDP_Evt));
}
#define mark_udp_evt_IS_ATOMIC 0
#define mark_udp_evt_IS_CONST_SIZE 1
# endif
#endif

72
src/racket/src/mzmark_optimize.inc Normal file
View File

@ -0,0 +1,72 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_optimize_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Optimize_Info));
}
static int mark_optimize_info_MARK(void *p, struct NewGC *gc) {
Optimize_Info *i = (Optimize_Info *)p;
gcMARK2(i->stat_dists, gc);
gcMARK2(i->sd_depths, gc);
gcMARK2(i->next, gc);
gcMARK2(i->use, gc);
gcMARK2(i->consts, gc);
gcMARK2(i->top_level_consts, gc);
gcMARK2(i->transitive_use, gc);
gcMARK2(i->transitive_use_len, gc);
gcMARK2(i->context, gc);
return
gcBYTES_TO_WORDS(sizeof(Optimize_Info));
}
static int mark_optimize_info_FIXUP(void *p, struct NewGC *gc) {
Optimize_Info *i = (Optimize_Info *)p;
gcFIXUP2(i->stat_dists, gc);
gcFIXUP2(i->sd_depths, gc);
gcFIXUP2(i->next, gc);
gcFIXUP2(i->use, gc);
gcFIXUP2(i->consts, gc);
gcFIXUP2(i->top_level_consts, gc);
gcFIXUP2(i->transitive_use, gc);
gcFIXUP2(i->transitive_use_len, gc);
gcFIXUP2(i->context, gc);
return
gcBYTES_TO_WORDS(sizeof(Optimize_Info));
}
#define mark_optimize_info_IS_ATOMIC 0
#define mark_optimize_info_IS_CONST_SIZE 1
static int mark_once_used_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used));
}
static int mark_once_used_MARK(void *p, struct NewGC *gc) {
Scheme_Once_Used *o = (Scheme_Once_Used *)p;
gcMARK2(o->expr, gc);
gcMARK2(o->info, gc);
gcMARK2(o->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used));
}
static int mark_once_used_FIXUP(void *p, struct NewGC *gc) {
Scheme_Once_Used *o = (Scheme_Once_Used *)p;
gcFIXUP2(o->expr, gc);
gcFIXUP2(o->info, gc);
gcFIXUP2(o->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Once_Used));
}
#define mark_once_used_IS_ATOMIC 0
#define mark_once_used_IS_CONST_SIZE 1

87
src/racket/src/mzmark_place.inc Normal file
View File

@ -0,0 +1,87 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int place_bi_channel_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel));
}
static int place_bi_channel_val_MARK(void *p, struct NewGC *gc) {
Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p;
gcMARK2(pbc->sendch, gc);
gcMARK2(pbc->recvch, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel));
}
static int place_bi_channel_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Place_Bi_Channel *pbc = (Scheme_Place_Bi_Channel *)p;
gcFIXUP2(pbc->sendch, gc);
gcFIXUP2(pbc->recvch, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Bi_Channel));
}
#define place_bi_channel_val_IS_ATOMIC 0
#define place_bi_channel_val_IS_CONST_SIZE 1
static int place_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place));
}
static int place_val_MARK(void *p, struct NewGC *gc) {
Scheme_Place *pr = (Scheme_Place *)p;
gcMARK2(pr->channel, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place));
}
static int place_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Place *pr = (Scheme_Place *)p;
gcFIXUP2(pr->channel, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place));
}
#define place_val_IS_ATOMIC 0
#define place_val_IS_CONST_SIZE 1
static int place_async_channel_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
}
static int place_async_channel_val_MARK(void *p, struct NewGC *gc) {
Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p;
int i;
gcMARK2(pac->msgs, gc);
gcMARK2(pac->msg_memory, gc);
for (i = pac->size; i--; )
gcMARK2(pac->msgs[i], gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
}
static int place_async_channel_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Place_Async_Channel *pac = (Scheme_Place_Async_Channel *)p;
int i;
gcFIXUP2(pac->msgs, gc);
gcFIXUP2(pac->msg_memory, gc);
for (i = pac->size; i--; )
gcFIXUP2(pac->msgs[i], gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
}
#define place_async_channel_val_IS_ATOMIC 0
#define place_async_channel_val_IS_CONST_SIZE 1

232
src/racket/src/mzmark_port.inc Normal file
View File

@ -0,0 +1,232 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
#ifdef WINDOWS_PROCESSES
static int mark_thread_memory_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
}
static int mark_thread_memory_MARK(void *p, struct NewGC *gc) {
Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p;
gcMARK2(tm->prev, gc);
gcMARK2(tm->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
}
static int mark_thread_memory_FIXUP(void *p, struct NewGC *gc) {
Scheme_Thread_Memory *tm = (Scheme_Thread_Memory *)p;
gcFIXUP2(tm->prev, gc);
gcFIXUP2(tm->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Memory));
}
#define mark_thread_memory_IS_ATOMIC 0
#define mark_thread_memory_IS_CONST_SIZE 1
#endif
static int mark_input_file_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
}
static int mark_input_file_MARK(void *p, struct NewGC *gc) {
Scheme_Input_File *i = (Scheme_Input_File *)p;
gcMARK2(i->f, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
}
static int mark_input_file_FIXUP(void *p, struct NewGC *gc) {
Scheme_Input_File *i = (Scheme_Input_File *)p;
gcFIXUP2(i->f, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Input_File));
}
#define mark_input_file_IS_ATOMIC 0
#define mark_input_file_IS_CONST_SIZE 1
static int mark_output_file_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
}
static int mark_output_file_MARK(void *p, struct NewGC *gc) {
Scheme_Output_File *o = (Scheme_Output_File *)p;
gcMARK2(o->f, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
}
static int mark_output_file_FIXUP(void *p, struct NewGC *gc) {
Scheme_Output_File *o = (Scheme_Output_File *)p;
gcFIXUP2(o->f, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Output_File));
}
#define mark_output_file_IS_ATOMIC 0
#define mark_output_file_IS_CONST_SIZE 1
#ifdef MZ_FDS
static int mark_input_fd_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_FD));
}
static int mark_input_fd_MARK(void *p, struct NewGC *gc) {
Scheme_FD *fd = (Scheme_FD *)p;
gcMARK2(fd->buffer, gc);
gcMARK2(fd->refcount, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_FD));
}
static int mark_input_fd_FIXUP(void *p, struct NewGC *gc) {
Scheme_FD *fd = (Scheme_FD *)p;
gcFIXUP2(fd->buffer, gc);
gcFIXUP2(fd->refcount, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_FD));
}
#define mark_input_fd_IS_ATOMIC 0
#define mark_input_fd_IS_CONST_SIZE 1
#endif
#if defined(UNIX_PROCESSES) && !(defined(MZ_USE_PLACES) && defined(MZ_PRECISE_GC))
static int mark_system_child_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(System_Child));
}
static int mark_system_child_MARK(void *p, struct NewGC *gc) {
System_Child *sc = (System_Child *)p;
gcMARK2(sc->next, gc);
return
gcBYTES_TO_WORDS(sizeof(System_Child));
}
static int mark_system_child_FIXUP(void *p, struct NewGC *gc) {
System_Child *sc = (System_Child *)p;
gcFIXUP2(sc->next, gc);
return
gcBYTES_TO_WORDS(sizeof(System_Child));
}
#define mark_system_child_IS_ATOMIC 0
#define mark_system_child_IS_CONST_SIZE 1
#endif
#ifdef USE_OSKIT_CONSOLE
static int mark_oskit_console_input_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(osk_console_input));
}
static int mark_oskit_console_input_MARK(void *p, struct NewGC *gc) {
osk_console_input *c = (osk_console_input *)p;
gcMARK2(c->buffer, gc);
gcMARK2(c->next, gc);
return
gcBYTES_TO_WORDS(sizeof(osk_console_input));
}
static int mark_oskit_console_input_FIXUP(void *p, struct NewGC *gc) {
osk_console_input *c = (osk_console_input *)p;
gcFIXUP2(c->buffer, gc);
gcFIXUP2(c->next, gc);
return
gcBYTES_TO_WORDS(sizeof(osk_console_input));
}
#define mark_oskit_console_input_IS_ATOMIC 0
#define mark_oskit_console_input_IS_CONST_SIZE 1
#endif
static int mark_subprocess_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
}
static int mark_subprocess_MARK(void *p, struct NewGC *gc) {
#ifndef WINDOWS_PROCESSES
Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
gcMARK2(sp->handle, gc);
gcMARK2(sp->mref, gc);
#endif
return
gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
}
static int mark_subprocess_FIXUP(void *p, struct NewGC *gc) {
#ifndef WINDOWS_PROCESSES
Scheme_Subprocess *sp = (Scheme_Subprocess *)p;
gcFIXUP2(sp->handle, gc);
gcFIXUP2(sp->mref, gc);
#endif
return
gcBYTES_TO_WORDS(sizeof(Scheme_Subprocess));
}
#define mark_subprocess_IS_ATOMIC 0
#define mark_subprocess_IS_CONST_SIZE 1
static int mark_read_write_evt_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
}
static int mark_read_write_evt_MARK(void *p, struct NewGC *gc) {
Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
gcMARK2(rww->port, gc);
gcMARK2(rww->v, gc);
gcMARK2(rww->str, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
}
static int mark_read_write_evt_FIXUP(void *p, struct NewGC *gc) {
Scheme_Read_Write_Evt *rww = (Scheme_Read_Write_Evt *)p;
gcFIXUP2(rww->port, gc);
gcFIXUP2(rww->v, gc);
gcFIXUP2(rww->str, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Read_Write_Evt));
}
#define mark_read_write_evt_IS_ATOMIC 0
#define mark_read_write_evt_IS_CONST_SIZE 1

154
src/racket/src/mzmark_portfun.inc Normal file
View File

@ -0,0 +1,154 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_load_handler_data_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
}
static int mark_load_handler_data_MARK(void *p, struct NewGC *gc) {
LoadHandlerData *d = (LoadHandlerData *)p;
gcMARK2(d->config, gc);
gcMARK2(d->port, gc);
gcMARK2(d->p, gc);
gcMARK2(d->stxsrc, gc);
gcMARK2(d->expected_module, gc);
gcMARK2(d->delay_load_info, gc);
return
gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
}
static int mark_load_handler_data_FIXUP(void *p, struct NewGC *gc) {
LoadHandlerData *d = (LoadHandlerData *)p;
gcFIXUP2(d->config, gc);
gcFIXUP2(d->port, gc);
gcFIXUP2(d->p, gc);
gcFIXUP2(d->stxsrc, gc);
gcFIXUP2(d->expected_module, gc);
gcFIXUP2(d->delay_load_info, gc);
return
gcBYTES_TO_WORDS(sizeof(LoadHandlerData));
}
#define mark_load_handler_data_IS_ATOMIC 0
#define mark_load_handler_data_IS_CONST_SIZE 1
static int mark_indexed_string_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
}
static int mark_indexed_string_MARK(void *p, struct NewGC *gc) {
Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
gcMARK2(is->string, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
}
static int mark_indexed_string_FIXUP(void *p, struct NewGC *gc) {
Scheme_Indexed_String *is = (Scheme_Indexed_String *)p;
gcFIXUP2(is->string, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indexed_String));
}
#define mark_indexed_string_IS_ATOMIC 0
#define mark_indexed_string_IS_CONST_SIZE 1
static int mark_user_input_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(User_Input_Port));
}
static int mark_user_input_MARK(void *p, struct NewGC *gc) {
User_Input_Port *uip = (User_Input_Port *)p;
gcMARK2(uip->read_proc, gc);
gcMARK2(uip->peek_proc, gc);
gcMARK2(uip->progress_evt_proc, gc);
gcMARK2(uip->peeked_read_proc, gc);
gcMARK2(uip->location_proc, gc);
gcMARK2(uip->count_lines_proc, gc);
gcMARK2(uip->buffer_mode_proc, gc);
gcMARK2(uip->close_proc, gc);
gcMARK2(uip->reuse_str, gc);
gcMARK2(uip->peeked, gc);
gcMARK2(uip->prefix_pipe, gc);
return
gcBYTES_TO_WORDS(sizeof(User_Input_Port));
}
static int mark_user_input_FIXUP(void *p, struct NewGC *gc) {
User_Input_Port *uip = (User_Input_Port *)p;
gcFIXUP2(uip->read_proc, gc);
gcFIXUP2(uip->peek_proc, gc);
gcFIXUP2(uip->progress_evt_proc, gc);
gcFIXUP2(uip->peeked_read_proc, gc);
gcFIXUP2(uip->location_proc, gc);
gcFIXUP2(uip->count_lines_proc, gc);
gcFIXUP2(uip->buffer_mode_proc, gc);
gcFIXUP2(uip->close_proc, gc);
gcFIXUP2(uip->reuse_str, gc);
gcFIXUP2(uip->peeked, gc);
gcFIXUP2(uip->prefix_pipe, gc);
return
gcBYTES_TO_WORDS(sizeof(User_Input_Port));
}
#define mark_user_input_IS_ATOMIC 0
#define mark_user_input_IS_CONST_SIZE 1
static int mark_user_output_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(User_Output_Port));
}
static int mark_user_output_MARK(void *p, struct NewGC *gc) {
User_Output_Port *uop = (User_Output_Port *)p;
gcMARK2(uop->evt, gc);
gcMARK2(uop->write_evt_proc, gc);
gcMARK2(uop->write_proc, gc);
gcMARK2(uop->write_special_evt_proc, gc);
gcMARK2(uop->write_special_proc, gc);
gcMARK2(uop->location_proc, gc);
gcMARK2(uop->count_lines_proc, gc);
gcMARK2(uop->buffer_mode_proc, gc);
gcMARK2(uop->close_proc, gc);
gcMARK2(uop->buffer_pipe, gc);
return
gcBYTES_TO_WORDS(sizeof(User_Output_Port));
}
static int mark_user_output_FIXUP(void *p, struct NewGC *gc) {
User_Output_Port *uop = (User_Output_Port *)p;
gcFIXUP2(uop->evt, gc);
gcFIXUP2(uop->write_evt_proc, gc);
gcFIXUP2(uop->write_proc, gc);
gcFIXUP2(uop->write_special_evt_proc, gc);
gcFIXUP2(uop->write_special_proc, gc);
gcFIXUP2(uop->location_proc, gc);
gcFIXUP2(uop->count_lines_proc, gc);
gcFIXUP2(uop->buffer_mode_proc, gc);
gcFIXUP2(uop->close_proc, gc);
gcFIXUP2(uop->buffer_pipe, gc);
return
gcBYTES_TO_WORDS(sizeof(User_Output_Port));
}
#define mark_user_output_IS_ATOMIC 0
#define mark_user_output_IS_CONST_SIZE 1

86
src/racket/src/mzmark_print.inc Normal file
View File

@ -0,0 +1,86 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_print_params_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(PrintParams));
}
static int mark_print_params_MARK(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(PrintParams));
}
static int mark_print_params_FIXUP(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(PrintParams));
}
#define mark_print_params_IS_ATOMIC 0
#define mark_print_params_IS_CONST_SIZE 1
static int mark_marshal_tables_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
}
static int mark_marshal_tables_MARK(void *p, struct NewGC *gc) {
Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
gcMARK2(mt->symtab, gc);
gcMARK2(mt->rns, gc);
gcMARK2(mt->rn_refs, gc);
gcMARK2(mt->st_refs, gc);
gcMARK2(mt->st_ref_stack, gc);
gcMARK2(mt->reverse_map, gc);
gcMARK2(mt->same_map, gc);
gcMARK2(mt->cert_lists, gc);
gcMARK2(mt->shift_map, gc);
gcMARK2(mt->top_map, gc);
gcMARK2(mt->key_map, gc);
gcMARK2(mt->delay_map, gc);
gcMARK2(mt->cdata_map, gc);
gcMARK2(mt->rn_saved, gc);
gcMARK2(mt->shared_offsets, gc);
gcMARK2(mt->sorted_keys, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
}
static int mark_marshal_tables_FIXUP(void *p, struct NewGC *gc) {
Scheme_Marshal_Tables *mt = (Scheme_Marshal_Tables *)p;
gcFIXUP2(mt->symtab, gc);
gcFIXUP2(mt->rns, gc);
gcFIXUP2(mt->rn_refs, gc);
gcFIXUP2(mt->st_refs, gc);
gcFIXUP2(mt->st_ref_stack, gc);
gcFIXUP2(mt->reverse_map, gc);
gcFIXUP2(mt->same_map, gc);
gcFIXUP2(mt->cert_lists, gc);
gcFIXUP2(mt->shift_map, gc);
gcFIXUP2(mt->top_map, gc);
gcFIXUP2(mt->key_map, gc);
gcFIXUP2(mt->delay_map, gc);
gcFIXUP2(mt->cdata_map, gc);
gcFIXUP2(mt->rn_saved, gc);
gcFIXUP2(mt->shared_offsets, gc);
gcFIXUP2(mt->sorted_keys, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Marshal_Tables));
}
#define mark_marshal_tables_IS_ATOMIC 0
#define mark_marshal_tables_IS_CONST_SIZE 1

190
src/racket/src/mzmark_read.inc Normal file
View File

@ -0,0 +1,190 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_indent_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
}
static int mark_indent_MARK(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
}
static int mark_indent_FIXUP(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Indent));
}
#define mark_indent_IS_ATOMIC 1
#define mark_indent_IS_CONST_SIZE 1
static int mark_cport_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(CPort));
}
static int mark_cport_MARK(void *p, struct NewGC *gc) {
CPort *cp = (CPort *)p;
gcMARK2(cp->start, gc);
gcMARK2(cp->orig_port, gc);
gcMARK2(cp->ht, gc);
gcMARK2(cp->ut, gc);
gcMARK2(cp->symtab, gc);
gcMARK2(cp->insp, gc);
gcMARK2(cp->relto, gc);
gcMARK2(cp->magic_sym, gc);
gcMARK2(cp->magic_val, gc);
gcMARK2(cp->shared_offsets, gc);
gcMARK2(cp->delay_info, gc);
return
gcBYTES_TO_WORDS(sizeof(CPort));
}
static int mark_cport_FIXUP(void *p, struct NewGC *gc) {
CPort *cp = (CPort *)p;
gcFIXUP2(cp->start, gc);
gcFIXUP2(cp->orig_port, gc);
gcFIXUP2(cp->ht, gc);
gcFIXUP2(cp->ut, gc);
gcFIXUP2(cp->symtab, gc);
gcFIXUP2(cp->insp, gc);
gcFIXUP2(cp->relto, gc);
gcFIXUP2(cp->magic_sym, gc);
gcFIXUP2(cp->magic_val, gc);
gcFIXUP2(cp->shared_offsets, gc);
gcFIXUP2(cp->delay_info, gc);
return
gcBYTES_TO_WORDS(sizeof(CPort));
}
#define mark_cport_IS_ATOMIC 0
#define mark_cport_IS_CONST_SIZE 1
static int mark_readtable_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Readtable));
}
static int mark_readtable_MARK(void *p, struct NewGC *gc) {
Readtable *t = (Readtable *)p;
gcMARK2(t->mapping, gc);
gcMARK2(t->fast_mapping, gc);
gcMARK2(t->symbol_parser, gc);
gcMARK2(t->names, gc);
return
gcBYTES_TO_WORDS(sizeof(Readtable));
}
static int mark_readtable_FIXUP(void *p, struct NewGC *gc) {
Readtable *t = (Readtable *)p;
gcFIXUP2(t->mapping, gc);
gcFIXUP2(t->fast_mapping, gc);
gcFIXUP2(t->symbol_parser, gc);
gcFIXUP2(t->names, gc);
return
gcBYTES_TO_WORDS(sizeof(Readtable));
}
#define mark_readtable_IS_ATOMIC 0
#define mark_readtable_IS_CONST_SIZE 1
static int mark_read_params_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(ReadParams));
}
static int mark_read_params_MARK(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(ReadParams));
}
static int mark_read_params_FIXUP(void *p, struct NewGC *gc) {
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);
return
gcBYTES_TO_WORDS(sizeof(ReadParams));
}
#define mark_read_params_IS_ATOMIC 0
#define mark_read_params_IS_CONST_SIZE 1
static int mark_delay_load_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
}
static int mark_delay_load_MARK(void *p, struct NewGC *gc) {
Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
gcMARK2(ld->path, gc);
gcMARK2(ld->symtab, gc);
gcMARK2(ld->shared_offsets, gc);
gcMARK2(ld->insp, gc);
gcMARK2(ld->relto, gc);
gcMARK2(ld->ut, gc);
gcMARK2(ld->current_rp, gc);
gcMARK2(ld->cached, gc);
gcMARK2(ld->cached_port, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
}
static int mark_delay_load_FIXUP(void *p, struct NewGC *gc) {
Scheme_Load_Delay *ld = (Scheme_Load_Delay *)p;
gcFIXUP2(ld->path, gc);
gcFIXUP2(ld->symtab, gc);
gcFIXUP2(ld->shared_offsets, gc);
gcFIXUP2(ld->insp, gc);
gcFIXUP2(ld->relto, gc);
gcFIXUP2(ld->ut, gc);
gcFIXUP2(ld->current_rp, gc);
gcFIXUP2(ld->cached, gc);
gcFIXUP2(ld->cached_port, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Load_Delay));
}
#define mark_delay_load_IS_ATOMIC 0
#define mark_delay_load_IS_CONST_SIZE 1
static int mark_unmarshal_tables_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
}
static int mark_unmarshal_tables_MARK(void *p, struct NewGC *gc) {
Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
gcMARK2(ut->rns, gc);
gcMARK2(ut->rp, gc);
gcMARK2(ut->decoded, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
}
static int mark_unmarshal_tables_FIXUP(void *p, struct NewGC *gc) {
Scheme_Unmarshal_Tables *ut = (Scheme_Unmarshal_Tables *)p;
gcFIXUP2(ut->rns, gc);
gcFIXUP2(ut->rp, gc);
gcFIXUP2(ut->decoded, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Unmarshal_Tables));
}
#define mark_unmarshal_tables_IS_ATOMIC 0
#define mark_unmarshal_tables_IS_CONST_SIZE 1

71
src/racket/src/mzmark_regexp.inc Normal file
View File

@ -0,0 +1,71 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_regexp_SIZE(void *p, struct NewGC *gc) {
regexp *r = (regexp *)p;
return
gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
}
static int mark_regexp_MARK(void *p, struct NewGC *gc) {
regexp *r = (regexp *)p;
gcMARK2(r->source, gc);
gcMARK2(r->regstart, gc);
return
gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
}
static int mark_regexp_FIXUP(void *p, struct NewGC *gc) {
regexp *r = (regexp *)p;
gcFIXUP2(r->source, gc);
gcFIXUP2(r->regstart, gc);
return
gcBYTES_TO_WORDS((sizeof(regexp) + r->regsize));
}
#define mark_regexp_IS_ATOMIC 0
#define mark_regexp_IS_CONST_SIZE 0
static int mark_regwork_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Regwork));
}
static int mark_regwork_MARK(void *p, struct NewGC *gc) {
Regwork *r = (Regwork *)p;
gcMARK2(r->str, gc);
gcMARK2(r->instr, gc);
gcMARK2(r->port, gc);
gcMARK2(r->unless_evt, gc);
gcMARK2(r->startp, gc);
gcMARK2(r->maybep, gc);
gcMARK2(r->endp, gc);
gcMARK2(r->counters, gc);
gcMARK2(r->peekskip, gc);
gcMARK2(r->prefix, gc);
gcMARK2(r->rewind_stack, gc);
return
gcBYTES_TO_WORDS(sizeof(Regwork));
}
static int mark_regwork_FIXUP(void *p, struct NewGC *gc) {
Regwork *r = (Regwork *)p;
gcFIXUP2(r->str, gc);
gcFIXUP2(r->instr, gc);
gcFIXUP2(r->port, gc);
gcFIXUP2(r->unless_evt, gc);
gcFIXUP2(r->startp, gc);
gcFIXUP2(r->maybep, gc);
gcFIXUP2(r->endp, gc);
gcFIXUP2(r->counters, gc);
gcFIXUP2(r->peekskip, gc);
gcFIXUP2(r->prefix, gc);
gcFIXUP2(r->rewind_stack, gc);
return
gcBYTES_TO_WORDS(sizeof(Regwork));
}
#define mark_regwork_IS_ATOMIC 0
#define mark_regwork_IS_CONST_SIZE 1

47
src/racket/src/mzmark_resolve.inc Normal file
View File

@ -0,0 +1,47 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_resolve_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Resolve_Info));
}
static int mark_resolve_info_MARK(void *p, struct NewGC *gc) {
Resolve_Info *i = (Resolve_Info *)p;
gcMARK2(i->prefix, gc);
gcMARK2(i->stx_map, gc);
gcMARK2(i->tl_map, gc);
gcMARK2(i->old_pos, gc);
gcMARK2(i->new_pos, gc);
gcMARK2(i->old_stx_pos, gc);
gcMARK2(i->flags, gc);
gcMARK2(i->lifts, gc);
gcMARK2(i->lifted, gc);
gcMARK2(i->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Resolve_Info));
}
static int mark_resolve_info_FIXUP(void *p, struct NewGC *gc) {
Resolve_Info *i = (Resolve_Info *)p;
gcFIXUP2(i->prefix, gc);
gcFIXUP2(i->stx_map, gc);
gcFIXUP2(i->tl_map, gc);
gcFIXUP2(i->old_pos, gc);
gcFIXUP2(i->new_pos, gc);
gcFIXUP2(i->old_stx_pos, gc);
gcFIXUP2(i->flags, gc);
gcFIXUP2(i->lifts, gc);
gcFIXUP2(i->lifted, gc);
gcFIXUP2(i->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Resolve_Info));
}
#define mark_resolve_info_IS_ATOMIC 0
#define mark_resolve_info_IS_CONST_SIZE 1

68
src/racket/src/mzmark_salloc.inc Normal file
View File

@ -0,0 +1,68 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_finalization_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Finalization));
}
static int mark_finalization_MARK(void *p, struct NewGC *gc) {
Finalization *f = (Finalization *)p;
gcMARK2(f->data, gc);
gcMARK2(f->next, gc);
gcMARK2(f->prev, gc);
return
gcBYTES_TO_WORDS(sizeof(Finalization));
}
static int mark_finalization_FIXUP(void *p, struct NewGC *gc) {
Finalization *f = (Finalization *)p;
gcFIXUP2(f->data, gc);
gcFIXUP2(f->next, gc);
gcFIXUP2(f->prev, gc);
return
gcBYTES_TO_WORDS(sizeof(Finalization));
}
#define mark_finalization_IS_ATOMIC 0
#define mark_finalization_IS_CONST_SIZE 1
static int mark_finalizations_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Finalizations));
}
static int mark_finalizations_MARK(void *p, struct NewGC *gc) {
Finalizations *f = (Finalizations *)p;
gcMARK2(f->scheme_first, gc);
gcMARK2(f->scheme_last, gc);
gcMARK2(f->prim_first, gc);
gcMARK2(f->prim_last, gc);
gcMARK2(f->ext_data, gc);
return
gcBYTES_TO_WORDS(sizeof(Finalizations));
}
static int mark_finalizations_FIXUP(void *p, struct NewGC *gc) {
Finalizations *f = (Finalizations *)p;
gcFIXUP2(f->scheme_first, gc);
gcFIXUP2(f->scheme_last, gc);
gcFIXUP2(f->prim_first, gc);
gcFIXUP2(f->prim_last, gc);
gcFIXUP2(f->ext_data, gc);
return
gcBYTES_TO_WORDS(sizeof(Finalizations));
}
#define mark_finalizations_IS_ATOMIC 0
#define mark_finalizations_IS_CONST_SIZE 1

56
src/racket/src/mzmark_sema.inc Normal file
View File

@ -0,0 +1,56 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_channel_syncer_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
}
static int mark_channel_syncer_MARK(void *p, struct NewGC *gc) {
Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
gcMARK2(w->p, gc);
gcMARK2(w->prev, gc);
gcMARK2(w->next, gc);
gcMARK2(w->syncing, gc);
gcMARK2(w->obj, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
}
static int mark_channel_syncer_FIXUP(void *p, struct NewGC *gc) {
Scheme_Channel_Syncer *w = (Scheme_Channel_Syncer *)p;
gcFIXUP2(w->p, gc);
gcFIXUP2(w->prev, gc);
gcFIXUP2(w->next, gc);
gcFIXUP2(w->syncing, gc);
gcFIXUP2(w->obj, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Channel_Syncer));
}
#define mark_channel_syncer_IS_ATOMIC 0
#define mark_channel_syncer_IS_CONST_SIZE 1
static int mark_alarm_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
}
static int mark_alarm_MARK(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
}
static int mark_alarm_FIXUP(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Alarm));
}
#define mark_alarm_IS_ATOMIC 1
#define mark_alarm_IS_CONST_SIZE 1

33
src/racket/src/mzmark_sfs.inc Normal file
View File

@ -0,0 +1,33 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_sfs_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(SFS_Info));
}
static int mark_sfs_info_MARK(void *p, struct NewGC *gc) {
SFS_Info *i = (SFS_Info *)p;
gcMARK2(i->max_used, gc);
gcMARK2(i->max_calls, gc);
gcMARK2(i->saved, gc);
return
gcBYTES_TO_WORDS(sizeof(SFS_Info));
}
static int mark_sfs_info_FIXUP(void *p, struct NewGC *gc) {
SFS_Info *i = (SFS_Info *)p;
gcFIXUP2(i->max_used, gc);
gcFIXUP2(i->max_calls, gc);
gcFIXUP2(i->saved, gc);
return
gcBYTES_TO_WORDS(sizeof(SFS_Info));
}
#define mark_sfs_info_IS_ATOMIC 0
#define mark_sfs_info_IS_CONST_SIZE 1

25
src/racket/src/mzmark_string.inc Normal file
View File

@ -0,0 +1,25 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_string_convert_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
}
static int mark_string_convert_MARK(void *p, struct NewGC *gc) {
Scheme_Converter *c = (Scheme_Converter *)p;
gcMARK2(c->mref, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
}
static int mark_string_convert_FIXUP(void *p, struct NewGC *gc) {
Scheme_Converter *c = (Scheme_Converter *)p;
gcFIXUP2(c->mref, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Converter));
}
#define mark_string_convert_IS_ATOMIC 0
#define mark_string_convert_IS_CONST_SIZE 1

297
src/racket/src/mzmark_struct.inc Normal file
View File

@ -0,0 +1,297 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
#ifdef MZ_USE_PLACES
static int mark_serialized_struct_val_SIZE(void *p, struct NewGC *gc) {
Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
int num_slots = s->num_slots;
return
gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
+ ((num_slots - 1) * sizeof(Scheme_Object *))));
}
static int mark_serialized_struct_val_MARK(void *p, struct NewGC *gc) {
Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
int num_slots = s->num_slots;
int i;
gcMARK2(s->prefab_key, gc);
for(i = num_slots; i--; )
gcMARK2(s->slots[i], gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
+ ((num_slots - 1) * sizeof(Scheme_Object *))));
}
static int mark_serialized_struct_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Serialized_Structure *s = (Scheme_Serialized_Structure *)p;
int num_slots = s->num_slots;
int i;
gcFIXUP2(s->prefab_key, gc);
for(i = num_slots; i--; )
gcFIXUP2(s->slots[i], gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Serialized_Structure)
+ ((num_slots - 1) * sizeof(Scheme_Object *))));
}
#define mark_serialized_struct_val_IS_ATOMIC 0
#define mark_serialized_struct_val_IS_CONST_SIZE 0
#endif
static int mark_struct_val_SIZE(void *p, struct NewGC *gc) {
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 - 1) * sizeof(Scheme_Object *))));
}
static int mark_struct_val_MARK(void *p, struct NewGC *gc) {
Scheme_Structure *s = (Scheme_Structure *)p;
int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
int i;
gcMARK2( s->stype, gc);
for(i = num_slots; i--; )
gcMARK2(s->slots[i], gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
+ ((num_slots - 1) * sizeof(Scheme_Object *))));
}
static int mark_struct_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Structure *s = (Scheme_Structure *)p;
int num_slots = ((Scheme_Struct_Type *)GC_resolve2(s->stype, gc))->num_slots;
int i;
gcFIXUP2_TYPED_NOW(Scheme_Struct_Type *, s->stype, gc);
for(i = num_slots; i--; )
gcFIXUP2(s->slots[i], gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Structure)
+ ((num_slots - 1) * sizeof(Scheme_Object *))));
}
#define mark_struct_val_IS_ATOMIC 0
#define mark_struct_val_IS_CONST_SIZE 0
static int mark_struct_type_val_SIZE(void *p, struct NewGC *gc) {
Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
return
gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
+ (t->name_pos * sizeof(Scheme_Struct_Type *))));
}
static int mark_struct_type_val_MARK(void *p, struct NewGC *gc) {
Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
int i;
for (i = t->name_pos + 1; i--; ) {
gcMARK2(t->parent_types[i], gc);
}
gcMARK2(t->name, gc);
gcMARK2(t->inspector, gc);
gcMARK2(t->accessor, gc);
gcMARK2(t->mutator, gc);
gcMARK2(t->prefab_key, gc);
gcMARK2(t->uninit_val, gc);
gcMARK2(t->props, gc);
gcMARK2(t->proc_attr, gc);
gcMARK2(t->guard, gc);
gcMARK2(t->immutables, gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
+ (t->name_pos * sizeof(Scheme_Struct_Type *))));
}
static int mark_struct_type_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Struct_Type *t = (Scheme_Struct_Type *)p;
int i;
for (i = t->name_pos + 1; i--; ) {
gcFIXUP2(t->parent_types[i], gc);
}
gcFIXUP2(t->name, gc);
gcFIXUP2(t->inspector, gc);
gcFIXUP2(t->accessor, gc);
gcFIXUP2(t->mutator, gc);
gcFIXUP2(t->prefab_key, gc);
gcFIXUP2(t->uninit_val, gc);
gcFIXUP2(t->props, gc);
gcFIXUP2(t->proc_attr, gc);
gcFIXUP2(t->guard, gc);
gcFIXUP2(t->immutables, gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Struct_Type)
+ (t->name_pos * sizeof(Scheme_Struct_Type *))));
}
#define mark_struct_type_val_IS_ATOMIC 0
#define mark_struct_type_val_IS_CONST_SIZE 0
static int mark_struct_proc_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
}
static int mark_struct_proc_info_MARK(void *p, struct NewGC *gc) {
Struct_Proc_Info *i = (Struct_Proc_Info *)p;
gcMARK2(i->struct_type, gc);
gcMARK2(i->func_name, gc);
return
gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
}
static int mark_struct_proc_info_FIXUP(void *p, struct NewGC *gc) {
Struct_Proc_Info *i = (Struct_Proc_Info *)p;
gcFIXUP2(i->struct_type, gc);
gcFIXUP2(i->func_name, gc);
return
gcBYTES_TO_WORDS(sizeof(Struct_Proc_Info));
}
#define mark_struct_proc_info_IS_ATOMIC 0
#define mark_struct_proc_info_IS_CONST_SIZE 1
static int mark_struct_property_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
}
static int mark_struct_property_MARK(void *p, struct NewGC *gc) {
Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
gcMARK2(i->name, gc);
gcMARK2(i->guard, gc);
gcMARK2(i->supers, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
}
static int mark_struct_property_FIXUP(void *p, struct NewGC *gc) {
Scheme_Struct_Property *i = (Scheme_Struct_Property *)p;
gcFIXUP2(i->name, gc);
gcFIXUP2(i->guard, gc);
gcFIXUP2(i->supers, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Struct_Property));
}
#define mark_struct_property_IS_ATOMIC 0
#define mark_struct_property_IS_CONST_SIZE 1
static int mark_wrapped_evt_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
}
static int mark_wrapped_evt_MARK(void *p, struct NewGC *gc) {
Wrapped_Evt *ww = (Wrapped_Evt *)p;
gcMARK2(ww->evt, gc);
gcMARK2(ww->wrapper, gc);
return
gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
}
static int mark_wrapped_evt_FIXUP(void *p, struct NewGC *gc) {
Wrapped_Evt *ww = (Wrapped_Evt *)p;
gcFIXUP2(ww->evt, gc);
gcFIXUP2(ww->wrapper, gc);
return
gcBYTES_TO_WORDS(sizeof(Wrapped_Evt));
}
#define mark_wrapped_evt_IS_ATOMIC 0
#define mark_wrapped_evt_IS_CONST_SIZE 1
static int mark_nack_guard_evt_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
}
static int mark_nack_guard_evt_MARK(void *p, struct NewGC *gc) {
Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
gcMARK2(nw->maker, gc);
return
gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
}
static int mark_nack_guard_evt_FIXUP(void *p, struct NewGC *gc) {
Nack_Guard_Evt *nw = (Nack_Guard_Evt *)p;
gcFIXUP2(nw->maker, gc);
return
gcBYTES_TO_WORDS(sizeof(Nack_Guard_Evt));
}
#define mark_nack_guard_evt_IS_ATOMIC 0
#define mark_nack_guard_evt_IS_CONST_SIZE 1
static int mark_chaperone_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
}
static int mark_chaperone_MARK(void *p, struct NewGC *gc) {
Scheme_Chaperone *px = (Scheme_Chaperone *)p;
gcMARK2(px->val, gc);
gcMARK2(px->prev, gc);
gcMARK2(px->props, gc);
gcMARK2(px->redirects, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
}
static int mark_chaperone_FIXUP(void *p, struct NewGC *gc) {
Scheme_Chaperone *px = (Scheme_Chaperone *)p;
gcFIXUP2(px->val, gc);
gcFIXUP2(px->prev, gc);
gcFIXUP2(px->props, gc);
gcFIXUP2(px->redirects, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Chaperone));
}
#define mark_chaperone_IS_ATOMIC 0
#define mark_chaperone_IS_CONST_SIZE 1

221
src/racket/src/mzmark_syntax.inc Normal file
View File

@ -0,0 +1,221 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_rename_table_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Module_Renames));
}
static int mark_rename_table_MARK(void *p, struct NewGC *gc) {
Module_Renames *rn = (Module_Renames *)p;
gcMARK2(rn->phase, gc);
gcMARK2(rn->ht, gc);
gcMARK2(rn->nomarshal_ht, gc);
gcMARK2(rn->unmarshal_info, gc);
gcMARK2(rn->shared_pes, gc);
gcMARK2(rn->set_identity, gc);
gcMARK2(rn->marked_names, gc);
gcMARK2(rn->free_id_renames, gc);
return
gcBYTES_TO_WORDS(sizeof(Module_Renames));
}
static int mark_rename_table_FIXUP(void *p, struct NewGC *gc) {
Module_Renames *rn = (Module_Renames *)p;
gcFIXUP2(rn->phase, gc);
gcFIXUP2(rn->ht, gc);
gcFIXUP2(rn->nomarshal_ht, gc);
gcFIXUP2(rn->unmarshal_info, gc);
gcFIXUP2(rn->shared_pes, gc);
gcFIXUP2(rn->set_identity, gc);
gcFIXUP2(rn->marked_names, gc);
gcFIXUP2(rn->free_id_renames, gc);
return
gcBYTES_TO_WORDS(sizeof(Module_Renames));
}
#define mark_rename_table_IS_ATOMIC 0
#define mark_rename_table_IS_CONST_SIZE 1
static int mark_rename_table_set_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
}
static int mark_rename_table_set_MARK(void *p, struct NewGC *gc) {
Module_Renames_Set *rns = (Module_Renames_Set *)p;
gcMARK2(rns->et, gc);
gcMARK2(rns->rt, gc);
gcMARK2(rns->other_phases, gc);
gcMARK2(rns->share_marked_names, gc);
gcMARK2(rns->set_identity, gc);
return
gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
}
static int mark_rename_table_set_FIXUP(void *p, struct NewGC *gc) {
Module_Renames_Set *rns = (Module_Renames_Set *)p;
gcFIXUP2(rns->et, gc);
gcFIXUP2(rns->rt, gc);
gcFIXUP2(rns->other_phases, gc);
gcFIXUP2(rns->share_marked_names, gc);
gcFIXUP2(rns->set_identity, gc);
return
gcBYTES_TO_WORDS(sizeof(Module_Renames_Set));
}
#define mark_rename_table_set_IS_ATOMIC 0
#define mark_rename_table_set_IS_CONST_SIZE 1
static int mark_srcloc_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
}
static int mark_srcloc_MARK(void *p, struct NewGC *gc) {
Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
gcMARK2(s->src, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
}
static int mark_srcloc_FIXUP(void *p, struct NewGC *gc) {
Scheme_Stx_Srcloc *s = (Scheme_Stx_Srcloc *)p;
gcFIXUP2(s->src, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Stx_Srcloc));
}
#define mark_srcloc_IS_ATOMIC 0
#define mark_srcloc_IS_CONST_SIZE 1
static int mark_wrapchunk_SIZE(void *p, struct NewGC *gc) {
Wrap_Chunk *wc = (Wrap_Chunk *)p;
return
gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
}
static int mark_wrapchunk_MARK(void *p, struct NewGC *gc) {
Wrap_Chunk *wc = (Wrap_Chunk *)p;
int i;
for (i = wc->len; i--; ) {
gcMARK2(wc->a[i], gc);
}
return
gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
}
static int mark_wrapchunk_FIXUP(void *p, struct NewGC *gc) {
Wrap_Chunk *wc = (Wrap_Chunk *)p;
int i;
for (i = wc->len; i--; ) {
gcFIXUP2(wc->a[i], gc);
}
return
gcBYTES_TO_WORDS(sizeof(Wrap_Chunk) + ((wc->len - 1) * sizeof(Scheme_Object *)));
}
#define mark_wrapchunk_IS_ATOMIC 0
#define mark_wrapchunk_IS_CONST_SIZE 0
static int mark_cert_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
}
static int mark_cert_MARK(void *p, struct NewGC *gc) {
Scheme_Cert *c = (Scheme_Cert *)p;
gcMARK2(c->mark, gc);
gcMARK2(c->modidx, gc);
gcMARK2(c->insp, gc);
gcMARK2(c->key, gc);
gcMARK2(c->mapped, gc);
gcMARK2(c->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
}
static int mark_cert_FIXUP(void *p, struct NewGC *gc) {
Scheme_Cert *c = (Scheme_Cert *)p;
gcFIXUP2(c->mark, gc);
gcFIXUP2(c->modidx, gc);
gcFIXUP2(c->insp, gc);
gcFIXUP2(c->key, gc);
gcFIXUP2(c->mapped, gc);
gcFIXUP2(c->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Cert));
}
#define mark_cert_IS_ATOMIC 0
#define mark_cert_IS_CONST_SIZE 1
static int lex_rib_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
}
static int lex_rib_MARK(void *p, struct NewGC *gc) {
Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p;
gcMARK2(rib->rename, gc);
gcMARK2(rib->timestamp, gc);
gcMARK2(rib->sealed, gc);
gcMARK2(rib->mapped_names, gc);
gcMARK2(rib->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
}
static int lex_rib_FIXUP(void *p, struct NewGC *gc) {
Scheme_Lexical_Rib *rib = (Scheme_Lexical_Rib *)p;
gcFIXUP2(rib->rename, gc);
gcFIXUP2(rib->timestamp, gc);
gcFIXUP2(rib->sealed, gc);
gcFIXUP2(rib->mapped_names, gc);
gcFIXUP2(rib->next, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Lexical_Rib));
}
#define lex_rib_IS_ATOMIC 0
#define lex_rib_IS_CONST_SIZE 1
static int mark_free_id_info_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS((sizeof(Scheme_Vector)
+ ((8 - 1) * sizeof(Scheme_Object *))));
}
static int mark_free_id_info_MARK(void *p, struct NewGC *gc) {
Scheme_Vector *vec = (Scheme_Vector *)p;
int i;
for (i = 8; i--; )
gcMARK2(vec->els[i], gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Vector)
+ ((8 - 1) * sizeof(Scheme_Object *))));
}
static int mark_free_id_info_FIXUP(void *p, struct NewGC *gc) {
Scheme_Vector *vec = (Scheme_Vector *)p;
int i;
for (i = 8; i--; )
gcFIXUP2(vec->els[i], gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Vector)
+ ((8 - 1) * sizeof(Scheme_Object *))));
}
#define mark_free_id_info_IS_ATOMIC 0
#define mark_free_id_info_IS_CONST_SIZE 0

424
src/racket/src/mzmark_thread.inc Normal file
View File

@ -0,0 +1,424 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_parameterization_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
+ ((max_configs - 1) * sizeof(Scheme_Object*))));
}
static int mark_parameterization_MARK(void *p, struct NewGC *gc) {
Scheme_Parameterization *c = (Scheme_Parameterization *)p;
int i;
for (i = max_configs; i--; ) {
gcMARK2(c->prims[i], gc);
}
gcMARK2(c->extensions, gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
+ ((max_configs - 1) * sizeof(Scheme_Object*))));
}
static int mark_parameterization_FIXUP(void *p, struct NewGC *gc) {
Scheme_Parameterization *c = (Scheme_Parameterization *)p;
int i;
for (i = max_configs; i--; ) {
gcFIXUP2(c->prims[i], gc);
}
gcFIXUP2(c->extensions, gc);
return
gcBYTES_TO_WORDS((sizeof(Scheme_Parameterization)
+ ((max_configs - 1) * sizeof(Scheme_Object*))));
}
#define mark_parameterization_IS_ATOMIC 0
#define mark_parameterization_IS_CONST_SIZE 0
static int mark_config_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Config));
}
static int mark_config_MARK(void *p, struct NewGC *gc) {
Scheme_Config *config = (Scheme_Config *)p;
gcMARK2(config->ht, gc);
gcMARK2(config->root, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Config));
}
static int mark_config_FIXUP(void *p, struct NewGC *gc) {
Scheme_Config *config = (Scheme_Config *)p;
gcFIXUP2(config->ht, gc);
gcFIXUP2(config->root, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Config));
}
#define mark_config_IS_ATOMIC 0
#define mark_config_IS_CONST_SIZE 1
static int mark_will_executor_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(WillExecutor));
}
static int mark_will_executor_val_MARK(void *p, struct NewGC *gc) {
WillExecutor *e = (WillExecutor *)p;
gcMARK2(e->sema, gc);
gcMARK2(e->first, gc);
gcMARK2(e->last, gc);
return
gcBYTES_TO_WORDS(sizeof(WillExecutor));
}
static int mark_will_executor_val_FIXUP(void *p, struct NewGC *gc) {
WillExecutor *e = (WillExecutor *)p;
gcFIXUP2(e->sema, gc);
gcFIXUP2(e->first, gc);
gcFIXUP2(e->last, gc);
return
gcBYTES_TO_WORDS(sizeof(WillExecutor));
}
#define mark_will_executor_val_IS_ATOMIC 0
#define mark_will_executor_val_IS_CONST_SIZE 1
static int mark_custodian_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
}
static int mark_custodian_val_MARK(void *p, struct NewGC *gc) {
Scheme_Custodian *m = (Scheme_Custodian *)p;
gcMARK2(m->boxes, gc);
gcMARK2(m->mrefs, gc);
gcMARK2(m->closers, gc);
gcMARK2(m->data, gc);
gcMARK2(m->parent, gc);
gcMARK2(m->sibling, gc);
gcMARK2(m->children, gc);
gcMARK2(m->global_next, gc);
gcMARK2(m->global_prev, gc);
gcMARK2(m->cust_boxes, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
}
static int mark_custodian_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Custodian *m = (Scheme_Custodian *)p;
gcFIXUP2(m->boxes, gc);
gcFIXUP2(m->mrefs, gc);
gcFIXUP2(m->closers, gc);
gcFIXUP2(m->data, gc);
gcFIXUP2(m->parent, gc);
gcFIXUP2(m->sibling, gc);
gcFIXUP2(m->children, gc);
gcFIXUP2(m->global_next, gc);
gcFIXUP2(m->global_prev, gc);
gcFIXUP2(m->cust_boxes, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian));
}
#define mark_custodian_val_IS_ATOMIC 0
#define mark_custodian_val_IS_CONST_SIZE 1
static int mark_custodian_box_val_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
}
static int mark_custodian_box_val_MARK(void *p, struct NewGC *gc) {
Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down;
gcMARK2(b->cust, gc);
if (!sd) {
gcMARK2(b->v, gc);
}
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
}
static int mark_custodian_box_val_FIXUP(void *p, struct NewGC *gc) {
Scheme_Custodian_Box *b = (Scheme_Custodian_Box *)p;
int sd = ((Scheme_Custodian *)GC_resolve2(b->cust, gc))->shut_down;
gcFIXUP2(b->cust, gc);
if (!sd) {
gcFIXUP2(b->v, gc);
}
return
gcBYTES_TO_WORDS(sizeof(Scheme_Custodian_Box));
}
#define mark_custodian_box_val_IS_ATOMIC 0
#define mark_custodian_box_val_IS_CONST_SIZE 1
static int mark_thread_hop_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
}
static int mark_thread_hop_MARK(void *p, struct NewGC *gc) {
Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
gcMARK2(hop->p, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
}
static int mark_thread_hop_FIXUP(void *p, struct NewGC *gc) {
Scheme_Thread_Custodian_Hop *hop = (Scheme_Thread_Custodian_Hop *)p;
gcFIXUP2(hop->p, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Custodian_Hop));
}
#define mark_thread_hop_IS_ATOMIC 0
#define mark_thread_hop_IS_CONST_SIZE 1
static int mark_param_data_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(ParamData));
}
static int mark_param_data_MARK(void *p, struct NewGC *gc) {
ParamData *d = (ParamData *)p;
gcMARK2(d->key, gc);
gcMARK2(d->guard, gc);
gcMARK2(d->extract_guard, gc);
gcMARK2(d->defcell, gc);
return
gcBYTES_TO_WORDS(sizeof(ParamData));
}
static int mark_param_data_FIXUP(void *p, struct NewGC *gc) {
ParamData *d = (ParamData *)p;
gcFIXUP2(d->key, gc);
gcFIXUP2(d->guard, gc);
gcFIXUP2(d->extract_guard, gc);
gcFIXUP2(d->defcell, gc);
return
gcBYTES_TO_WORDS(sizeof(ParamData));
}
#define mark_param_data_IS_ATOMIC 0
#define mark_param_data_IS_CONST_SIZE 1
static int mark_will_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(ActiveWill));
}
static int mark_will_MARK(void *p, struct NewGC *gc) {
ActiveWill *w = (ActiveWill *)p;
gcMARK2(w->o, gc);
gcMARK2(w->proc, gc);
gcMARK2(w->w, gc);
gcMARK2(w->next, gc);
return
gcBYTES_TO_WORDS(sizeof(ActiveWill));
}
static int mark_will_FIXUP(void *p, struct NewGC *gc) {
ActiveWill *w = (ActiveWill *)p;
gcFIXUP2(w->o, gc);
gcFIXUP2(w->proc, gc);
gcFIXUP2(w->w, gc);
gcFIXUP2(w->next, gc);
return
gcBYTES_TO_WORDS(sizeof(ActiveWill));
}
#define mark_will_IS_ATOMIC 0
#define mark_will_IS_CONST_SIZE 1
static int mark_evt_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Evt));
}
static int mark_evt_MARK(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Evt));
}
static int mark_evt_FIXUP(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Evt));
}
#define mark_evt_IS_ATOMIC 1
#define mark_evt_IS_CONST_SIZE 1
static int mark_syncing_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Syncing));
}
static int mark_syncing_MARK(void *p, struct NewGC *gc) {
Syncing *w = (Syncing *)p;
gcMARK2(w->set, gc);
gcMARK2(w->wrapss, gc);
gcMARK2(w->nackss, gc);
gcMARK2(w->reposts, gc);
gcMARK2(w->accepts, gc);
gcMARK2(w->disable_break, gc);
return
gcBYTES_TO_WORDS(sizeof(Syncing));
}
static int mark_syncing_FIXUP(void *p, struct NewGC *gc) {
Syncing *w = (Syncing *)p;
gcFIXUP2(w->set, gc);
gcFIXUP2(w->wrapss, gc);
gcFIXUP2(w->nackss, gc);
gcFIXUP2(w->reposts, gc);
gcFIXUP2(w->accepts, gc);
gcFIXUP2(w->disable_break, gc);
return
gcBYTES_TO_WORDS(sizeof(Syncing));
}
#define mark_syncing_IS_ATOMIC 0
#define mark_syncing_IS_CONST_SIZE 1
static int mark_evt_set_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Evt_Set));
}
static int mark_evt_set_MARK(void *p, struct NewGC *gc) {
Evt_Set *w = (Evt_Set *)p;
gcMARK2(w->ws, gc);
gcMARK2(w->argv, gc);
return
gcBYTES_TO_WORDS(sizeof(Evt_Set));
}
static int mark_evt_set_FIXUP(void *p, struct NewGC *gc) {
Evt_Set *w = (Evt_Set *)p;
gcFIXUP2(w->ws, gc);
gcFIXUP2(w->argv, gc);
return
gcBYTES_TO_WORDS(sizeof(Evt_Set));
}
#define mark_evt_set_IS_ATOMIC 0
#define mark_evt_set_IS_CONST_SIZE 1
static int mark_thread_set_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
}
static int mark_thread_set_MARK(void *p, struct NewGC *gc) {
Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
gcMARK2(ts->parent, gc);
gcMARK2(ts->first, gc);
gcMARK2(ts->next, gc);
gcMARK2(ts->prev, gc);
gcMARK2(ts->search_start, gc);
gcMARK2(ts->current, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
}
static int mark_thread_set_FIXUP(void *p, struct NewGC *gc) {
Scheme_Thread_Set *ts = (Scheme_Thread_Set *)p;
gcFIXUP2(ts->parent, gc);
gcFIXUP2(ts->first, gc);
gcFIXUP2(ts->next, gc);
gcFIXUP2(ts->prev, gc);
gcFIXUP2(ts->search_start, gc);
gcFIXUP2(ts->current, gc);
return
gcBYTES_TO_WORDS(sizeof(Scheme_Thread_Set));
}
#define mark_thread_set_IS_ATOMIC 0
#define mark_thread_set_IS_CONST_SIZE 1
static int mark_thread_cell_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Thread_Cell));
}
static int mark_thread_cell_MARK(void *p, struct NewGC *gc) {
Thread_Cell *c = (Thread_Cell *)p;
gcMARK2(c->def_val, gc);
return
gcBYTES_TO_WORDS(sizeof(Thread_Cell));
}
static int mark_thread_cell_FIXUP(void *p, struct NewGC *gc) {
Thread_Cell *c = (Thread_Cell *)p;
gcFIXUP2(c->def_val, gc);
return
gcBYTES_TO_WORDS(sizeof(Thread_Cell));
}
#define mark_thread_cell_IS_ATOMIC 0
#define mark_thread_cell_IS_CONST_SIZE 1

2893
src/racket/src/mzmark_type.inc Normal file
View File

File diff suppressed because it is too large Load Diff

31
src/racket/src/mzmark_validate.inc Normal file
View File

@ -0,0 +1,31 @@
/* >>>> Generated by mkmarak.rkt from mzmarksrc.c <<<< */
static int mark_validate_clearing_SIZE(void *p, struct NewGC *gc) {
return
gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
}
static int mark_validate_clearing_MARK(void *p, struct NewGC *gc) {
Validate_Clearing *vc = (Validate_Clearing *)p;
gcMARK2(vc->stack, gc);
gcMARK2(vc->ncstack, gc);
return
gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
}
static int mark_validate_clearing_FIXUP(void *p, struct NewGC *gc) {
Validate_Clearing *vc = (Validate_Clearing *)p;
gcFIXUP2(vc->stack, gc);
gcFIXUP2(vc->ncstack, gc);
return
gcBYTES_TO_WORDS(sizeof(Validate_Clearing));
}
#define mark_validate_clearing_IS_ATOMIC 0
#define mark_validate_clearing_IS_CONST_SIZE 1

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

@ -1164,19 +1164,6 @@ END type;
/**********************************************************************/
START engine;
engine_val {
mark:
Scheme_Engine *en = (Scheme_Engine *)p;
size:
gcBYTES_TO_WORDS(sizeof(Scheme_Engine));
}
END engine;
/**********************************************************************/
START env;
END env;
@ -1341,22 +1328,6 @@ END validate;
/**********************************************************************/
START file;
mark_reply_item {
mark:
ReplyItem *r = (ReplyItem *)p;
gcMARK2(r->next, gc);
size:
gcBYTES_TO_WORDS(sizeof(ReplyItem));
}
END file;
/**********************************************************************/
START fun;
mark_closure_info {
@ -1462,7 +1433,7 @@ END hash;
/**********************************************************************/
START places;
START place;
place_bi_channel_val {
mark:
@ -1496,7 +1467,7 @@ place_async_channel_val {
gcBYTES_TO_WORDS(sizeof(Scheme_Place_Async_Channel));
}
END places;
END place;
/**********************************************************************/
@ -2492,5 +2463,3 @@ sequential_fsemaphore {
END future;
/**********************************************************************/
#define GC_REG_TRAV(type, base) GC_register_traversers2(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC)

3
src/racket/src/network.c
View File

@ -3369,8 +3369,7 @@ static void udp_evt_needs_wakeup(Scheme_Object *_uw, void *fds)
START_XFORM_SKIP;
#define MARKS_FOR_NETWORK_C
#include "mzmark.c"
#include "mzmark_network.inc"
static void register_traversers(void)
{

3
src/racket/src/optimize.c
View File

@ -5809,8 +5809,7 @@ static void optimize_info_done(Optimize_Info *info)
START_XFORM_SKIP;
#define MARKS_FOR_OPTIMIZE_C
#include "mzmark.c"
#include "mzmark_optimize.inc"
static void register_traversers(void)
{

3
src/racket/src/place.c
View File

@ -1758,8 +1758,7 @@ static Scheme_Object *scheme_place_async_receive(Scheme_Place_Async_Channel *ch)
START_XFORM_SKIP;
#define MARKS_FOR_PLACES_C
#include "mzmark.c"
#include "mzmark_place.inc"
static void register_traversers(void)
{

3
src/racket/src/port.c
View File

@ -9275,8 +9275,7 @@ void scheme_count_output_port(Scheme_Object *port, intptr_t *s, intptr_t *e,
START_XFORM_SKIP;
#define MARKS_FOR_PORT_C
#include "mzmark.c"
#include "mzmark_port.inc"
static void register_traversers(void)
{

3
src/racket/src/portfun.c
View File

@ -4584,8 +4584,7 @@ flush_output(int argc, Scheme_Object *argv[])
START_XFORM_SKIP;
#define MARKS_FOR_PORTFUN_C
#include "mzmark.c"
#include "mzmark_portfun.inc"
static void register_traversers(void)
{

3
src/racket/src/print.c
View File

@ -4015,8 +4015,7 @@ static void custom_write_struct(Scheme_Object *s, Scheme_Hash_Table *ht,
START_XFORM_SKIP;
#define MARKS_FOR_PRINT_C
#include "mzmark.c"
#include "mzmark_print.inc"
static void register_traversers(void)
{

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

@ -6505,8 +6505,7 @@ static Scheme_Object *expected_lang(const char *prefix, int ch,
START_XFORM_SKIP;
#define MARKS_FOR_READ_C
#include "mzmark.c"
#include "mzmark_read.inc"
static void register_traversers(void)
{

3
src/racket/src/regexp.c
View File

@ -5865,8 +5865,7 @@ int scheme_regexp_is_byte(Scheme_Object *re)
#ifdef MZ_PRECISE_GC
START_XFORM_SKIP;
#define MARKS_FOR_REGEXP_C
#include "mzmark.c"
#include "mzmark_regexp.inc"
END_XFORM_SKIP;
#endif

3
src/racket/src/resolve.c
View File

@ -2895,8 +2895,7 @@ static int resolving_in_procedure(Resolve_Info *info)
START_XFORM_SKIP;
#define MARKS_FOR_RESOLVE_C
#include "mzmark.c"
#include "mzmark_resolve.inc"
static void register_traversers(void)
{

3
src/racket/src/salloc.c
View File

@ -1357,8 +1357,7 @@ typedef struct Finalizations {
START_XFORM_SKIP;
#define MARKS_FOR_SALLOC_C
#include "mzmark.c"
#include "mzmark_salloc.inc"
END_XFORM_SKIP;

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

@ -125,6 +125,9 @@ int scheme_num_types(void);
#endif
#define GC_REG_TRAV(type, base) \
GC_register_traversers2(type, base ## _SIZE, base ## _MARK, base ## _FIXUP, base ## _IS_CONST_SIZE, base ## _IS_ATOMIC)
void scheme_reset_finalizations(void);
extern uintptr_t scheme_get_current_os_thread_stack_base(void);
@ -3642,14 +3645,5 @@ Scheme_Env *scheme_place_instance_init();
void scheme_place_instance_destroy();
void scheme_kill_green_thread_timer();
void scheme_place_check_for_interruption();
/*========================================================================*/
/* engine */
/*========================================================================*/
typedef struct Scheme_Engine {
Scheme_Object so;
} Scheme_Engine;
Scheme_Env *scheme_engine_instance_init();
#endif /* __mzscheme_private__ */

3
src/racket/src/sema.c
View File

@ -1303,8 +1303,7 @@ static Scheme_Object *make_sys_idle(int n, Scheme_Object **p)
START_XFORM_SKIP;
#define MARKS_FOR_SEMA_C
#include "mzmark.c"
#include "mzmark_sema.inc"
static void register_traversers(void)
{

3
src/racket/src/sfs.c
View File

@ -1259,8 +1259,7 @@ Scheme_Object *scheme_sfs_expr(Scheme_Object *expr, SFS_Info *info, int closure_
START_XFORM_SKIP;
#define MARKS_FOR_SFS_C
#include "mzmark.c"
#include "mzmark_sfs.inc"
static void register_traversers(void)
{

3
src/racket/src/string.c
View File

@ -5645,8 +5645,7 @@ void machine_details(char *buff)
START_XFORM_SKIP;
#define MARKS_FOR_STRING_C
#include "mzmark.c"
#include "mzmark_string.inc"
static void register_traversers(void)
{

3
src/racket/src/struct.c
View File

@ -5318,8 +5318,7 @@ Scheme_Hash_Tree *scheme_parse_chaperone_props(const char *who, int start_at, in
START_XFORM_SKIP;
#define MARKS_FOR_STRUCT_C
#include "mzmark.c"
#include "mzmark_struct.inc"
static void register_traversers(void)
{

3
src/racket/src/syntax.c
View File

@ -9392,8 +9392,7 @@ static Scheme_Object *read_free_id_info_prefix(Scheme_Object *obj, Scheme_Object
START_XFORM_SKIP;
#define MARKS_FOR_SYNTAX_C
#include "mzmark.c"
#include "mzmark_syntax.inc"
static void register_traversers(void)
{

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

@ -7913,8 +7913,7 @@ uintptr_t scheme_get_current_thread_stack_start(void)
START_XFORM_SKIP;
#define MARKS_FOR_THREAD_C
#include "mzmark.c"
#include "mzmark_thread.inc"
static void register_traversers(void)
{

3
src/racket/src/type.c
View File

@ -501,8 +501,7 @@ static void FIXUP_jmpup(Scheme_Jumpup_Buf *buf, struct NewGC *gc)
#define RUNSTACK_ZERO_VAL NULL
#define MARKS_FOR_TYPE_C
#include "mzmark.c"
#include "mzmark_type.inc"
void scheme_register_traversers(void)
{

3
src/racket/src/validate.c
View File

@ -1550,8 +1550,7 @@ void scheme_validate_expr(Mz_CPort *port, Scheme_Object *expr,
START_XFORM_SKIP;
#define MARKS_FOR_VALIDATE_C
#include "mzmark.c"
#include "mzmark_validate.inc"
static void register_traversers(void)
{