Back to index

plt-scheme  4.2.1
type.c
Go to the documentation of this file.
00001 /*
00002   MzScheme
00003   Copyright (c) 2004-2009 PLT Scheme Inc.
00004   Copyright (c) 1995-2001 Matthew Flatt
00005 
00006     This library is free software; you can redistribute it and/or
00007     modify it under the terms of the GNU Library General Public
00008     License as published by the Free Software Foundation; either
00009     version 2 of the License, or (at your option) any later version.
00010 
00011     This library is distributed in the hope that it will be useful,
00012     but WITHOUT ANY WARRANTY; without even the implied warranty of
00013     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014     Library General Public License for more details.
00015 
00016     You should have received a copy of the GNU Library General Public
00017     License along with this library; if not, write to the Free
00018     Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019     Boston, MA 02110-1301 USA.
00020 
00021   libscheme
00022   Copyright (c) 1994 Brent Benson
00023   All rights reserved.
00024 */
00025 
00026 #include "schpriv.h"
00027 #include <string.h>
00028 
00029 Scheme_Type_Reader *scheme_type_readers;
00030 Scheme_Type_Writer *scheme_type_writers;
00031 Scheme_Equal_Proc *scheme_type_equals;
00032 Scheme_Primary_Hash_Proc *scheme_type_hash1s;
00033 Scheme_Secondary_Hash_Proc *scheme_type_hash2s;
00034 
00035 static char **type_names;
00036 static Scheme_Type maxtype, allocmax;
00037 
00038 #ifdef MEMORY_COUNTING_ON
00039 long scheme_type_table_count;
00040 #endif
00041 
00042 static void init_type_arrays()
00043 {
00044   long n;
00045 
00046   REGISTER_SO(type_names);
00047   REGISTER_SO(scheme_type_readers);
00048   REGISTER_SO(scheme_type_writers);
00049   REGISTER_SO(scheme_type_equals);
00050   REGISTER_SO(scheme_type_hash1s);
00051   REGISTER_SO(scheme_type_hash2s);
00052   
00053   maxtype = _scheme_last_type_;
00054   allocmax = maxtype + 100;
00055 
00056   type_names = MALLOC_N(char *, allocmax);
00057   scheme_type_readers = MALLOC_N_ATOMIC(Scheme_Type_Reader, allocmax);
00058   n = allocmax * sizeof(Scheme_Type_Reader);
00059   memset((char *)scheme_type_readers, 0, n);
00060 
00061 #ifdef MEMORY_COUNTING_ON
00062   scheme_type_table_count += n;
00063   scheme_misc_count += (allocmax * sizeof(char *));
00064 #endif
00065 
00066   scheme_type_writers = MALLOC_N_ATOMIC(Scheme_Type_Writer, allocmax);
00067   n = allocmax * sizeof(Scheme_Type_Writer);
00068   memset((char *)scheme_type_writers, 0, n);
00069 
00070 #ifdef MEMORY_COUNTING_ON
00071   scheme_type_table_count += n;
00072 #endif  
00073 
00074   scheme_type_equals = MALLOC_N_ATOMIC(Scheme_Equal_Proc, allocmax);
00075   n = allocmax * sizeof(Scheme_Equal_Proc);
00076   memset((char *)scheme_type_equals, 0, n);
00077 
00078   scheme_type_hash1s = MALLOC_N_ATOMIC(Scheme_Primary_Hash_Proc, allocmax);
00079   n = allocmax * sizeof(Scheme_Primary_Hash_Proc);
00080   memset((char *)scheme_type_hash1s, 0, n);
00081 
00082   scheme_type_hash2s = MALLOC_N_ATOMIC(Scheme_Secondary_Hash_Proc, allocmax);
00083   n = allocmax * sizeof(Scheme_Secondary_Hash_Proc);
00084   memset((char *)scheme_type_hash2s, 0, n);
00085 }
00086 
00087 void
00088 scheme_init_type ()
00089 {
00090   if (!type_names)
00091     init_type_arrays();
00092 
00093 #define set_name(t, n) type_names[t] = n
00094 
00095   set_name(scheme_true_type, "<true>");
00096   set_name(scheme_false_type, "<false>");
00097   set_name(scheme_char_type, "<char>");
00098   set_name(scheme_local_type, "<local-code>");
00099   set_name(scheme_local_unbox_type, "<local-unbox-code>");
00100   set_name(scheme_variable_type, "<global-variable-code>");
00101   set_name(scheme_toplevel_type, "<variable-code>");
00102   set_name(scheme_module_variable_type, "<module-variable-code>");
00103   set_name(scheme_application_type, "<application-code>");
00104   set_name(scheme_application2_type, "<unary-application-code>");
00105   set_name(scheme_application3_type, "<binary-application-code>");
00106   set_name(scheme_compiled_unclosed_procedure_type, "<procedure-semi-code>");
00107   set_name(scheme_unclosed_procedure_type, "<procedure-code>");
00108   set_name(scheme_syntax_type, "<syntax-code>");
00109   set_name(scheme_compiled_syntax_type, "<syntax-semi-code>");
00110   set_name(scheme_branch_type, "<branch-code>");
00111   set_name(scheme_sequence_type, "<sequence-code>");
00112   set_name(scheme_case_lambda_sequence_type, "<case-lambda-code>");
00113   set_name(scheme_begin0_sequence_type, "<begin0-code>");
00114   set_name(scheme_with_cont_mark_type, "<with-continuation-mark-code>");
00115   set_name(scheme_quote_syntax_type, "<quote-syntax-code>");
00116 
00117   set_name(scheme_let_value_type, "<let-value-code>");
00118   set_name(scheme_let_void_type, "<let-void-code>");
00119   set_name(scheme_compiled_let_value_type, "<let-value-semi-code>");
00120   set_name(scheme_compiled_let_void_type, "<let-void-semi-code>");
00121   set_name(scheme_compiled_toplevel_type, "<variable-semi-code>");
00122   set_name(scheme_compiled_quote_syntax_type, "<quote-syntax-semi-code>");
00123   set_name(scheme_letrec_type, "<letrec-code>");
00124   set_name(scheme_let_one_type, "<let-one-code>");
00125   set_name(scheme_quote_compilation_type, "<quote-code>");
00126 
00127   set_name(scheme_eval_waiting_type, "<eval-waiting>");
00128   set_name(scheme_void_type, "<void>");
00129   set_name(scheme_prim_type, "<primitive>");
00130   set_name(scheme_closed_prim_type, "<primitive-closure>");
00131   set_name(scheme_closure_type, "<procedure>");
00132   set_name(scheme_native_closure_type, "<procedure>");
00133   set_name(scheme_cont_type, "<continuation>");
00134   set_name(scheme_tail_call_waiting_type, "<tail-call-waiting>");
00135   set_name(scheme_null_type, "<empty-list>");
00136   set_name(scheme_pair_type, "<pair>");
00137   set_name(scheme_mutable_pair_type, "<mutable-pair>");
00138   set_name(scheme_raw_pair_type, "<raw-pair>");
00139   set_name(scheme_box_type, "<box>");
00140   set_name(scheme_integer_type, "<fixnum-integer>");
00141   set_name(scheme_double_type, "<inexact-number>");
00142   set_name(scheme_float_type, "<inexact-number*>");
00143   set_name(scheme_undefined_type, "<undefined>");
00144   set_name(scheme_eof_type, "<eof>");
00145   set_name(scheme_input_port_type, "<input-port>");
00146   set_name(scheme_output_port_type, "<output-port>");
00147   set_name(scheme_thread_type, "<thread>");
00148   set_name(scheme_char_string_type, "<string>");
00149   set_name(scheme_byte_string_type, "<byte-string>");
00150   set_name(scheme_unix_path_type, "<unix-path>");
00151   set_name(scheme_windows_path_type, "<windows-path>");
00152   set_name(scheme_struct_property_type, "<struct-property>");
00153   set_name(scheme_structure_type, "<struct>");
00154 #ifdef USE_SENORA_GC
00155   set_name(scheme_proc_struct_type, "<procedure-struct>");
00156 #else
00157   set_name(scheme_proc_struct_type, "<struct>");
00158 #endif
00159   set_name(scheme_symbol_type, "<symbol>");
00160   set_name(scheme_keyword_type, "<keyword>");
00161   set_name(scheme_syntax_compiler_type, "<syntax-compiler>");
00162   set_name(scheme_macro_type, "<macro>");
00163   set_name(scheme_lazy_macro_type, "<lazy-macro>");
00164   set_name(scheme_vector_type, "<vector>");
00165   set_name(scheme_bignum_type, "<bignum-integer>");
00166   set_name(scheme_escaping_cont_type, "<escape-continuation>");
00167   set_name(scheme_sema_type, "<semaphore>");
00168   set_name(scheme_channel_type, "<channel>");
00169   set_name(scheme_channel_put_type, "<channel-put>");
00170   set_name(scheme_hash_table_type, "<hash>");
00171   set_name(scheme_hash_tree_type, "<hash>");
00172   set_name(scheme_bucket_table_type, "<hash>");
00173   set_name(scheme_module_registry_type, "<module-registry>");
00174   set_name(scheme_case_closure_type, "<procedure>");
00175   set_name(scheme_placeholder_type, "<placeholder>");
00176   set_name(scheme_table_placeholder_type, "<hash-table-placeholder>");
00177   set_name(scheme_weak_box_type, "<weak-box>");
00178   set_name(scheme_ephemeron_type, "<ephemeron>");
00179   set_name(scheme_rational_type, "<fractional-number>");
00180   set_name(scheme_complex_type, "<complex-number>");
00181   set_name(scheme_struct_type_type, "<struct-type>");
00182   set_name(scheme_listener_type, "<tcp-listener>");
00183   set_name(scheme_tcp_accept_evt_type, "<tcp-accept-evt>");
00184   set_name(scheme_namespace_type, "<namespace>");
00185   set_name(scheme_config_type, "<parameterization>");
00186   set_name(scheme_will_executor_type, "<will-executor>");
00187   set_name(scheme_random_state_type, "<pseudo-random-generator>");
00188   set_name(scheme_regexp_type, "<regexp>");
00189   set_name(scheme_rename_table_type, "<rename-table>");
00190   set_name(scheme_bucket_type, "<hash-table-bucket>");
00191   set_name(scheme_resolve_prefix_type, "<resolve-prefix>");
00192   set_name(scheme_readtable_type, "<readtable>");
00193 
00194   set_name(scheme_compilation_top_type, "<compiled-code>");
00195 
00196   set_name(scheme_svector_type, "<short-vector>");
00197 
00198   set_name(scheme_custodian_type, "<custodian>");
00199   set_name(scheme_cust_box_type, "<custodian-box>");
00200   set_name(scheme_cont_mark_set_type, "<continuation-mark-set>");
00201   set_name(scheme_cont_mark_chain_type, "<chain>");
00202 
00203   set_name(scheme_inspector_type, "<inspector>");
00204   
00205   set_name(scheme_stx_type, "<syntax>");
00206   set_name(scheme_stx_offset_type, "<internal-syntax-offset>");
00207   set_name(scheme_expanded_syntax_type, "<expanded-syntax>");
00208   set_name(scheme_set_macro_type, "<set!-transformer>");
00209   set_name(scheme_id_macro_type, "<rename-transformer>");
00210 
00211   set_name(scheme_module_type, "<module-code>");
00212   set_name(scheme_module_index_type, "<module-path-index>");
00213 
00214   set_name(scheme_subprocess_type, "<subprocess>");
00215 
00216   set_name(scheme_cpointer_type, "<cpointer>");
00217   set_name(scheme_offset_cpointer_type, "<cpointer>");
00218 
00219   set_name(scheme_wrap_chunk_type, "<wrap-chunk>");
00220 
00221   set_name(scheme_security_guard_type, "<security-guard>");
00222 
00223   set_name(scheme_indent_type, "<internal-indentation>");
00224 
00225   set_name(scheme_udp_type, "<udp-socket>");
00226   set_name(scheme_udp_evt_type, "<udp-socket-evt>");
00227 
00228   set_name(scheme_evt_set_type, "<evt-set>");
00229   set_name(scheme_wrap_evt_type, "<evt>");
00230   set_name(scheme_handle_evt_type, "<evt>");
00231   set_name(scheme_nack_evt_type, "<evt>");
00232   set_name(scheme_nack_guard_evt_type, "<evt>");
00233   set_name(scheme_poll_evt_type, "<evt>");
00234   set_name(scheme_semaphore_repost_type, "<semaphore-peek>");
00235   set_name(scheme_alarm_type, "<alarm-evt>");
00236   set_name(scheme_progress_evt_type, "<progress-evt>");
00237   set_name(scheme_write_evt_type, "<write-evt>");
00238   set_name(scheme_always_evt_type, "<always-evt>");
00239   set_name(scheme_never_evt_type, "<never-evt>");
00240   set_name(scheme_thread_recv_evt_type, "<thread-receive-evt>");
00241 
00242   set_name(scheme_thread_resume_type, "<thread-resume-evt>");
00243   set_name(scheme_thread_suspend_type, "<thread-suspend-evt>");
00244   set_name(scheme_thread_dead_type, "<thread-dead-evt>");
00245 
00246   set_name(scheme_thread_set_type, "<thread-set>");
00247   set_name(scheme_thread_cell_type, "<thread-cell>");
00248   set_name(scheme_thread_cell_values_type, "<thread-cell-values>");
00249 
00250   set_name(scheme_prompt_tag_type, "<continuation-prompt-tag>");
00251 
00252   set_name(scheme_string_converter_type, "<string-converter>");
00253 
00254   set_name(scheme_channel_syncer_type, "<channel-syncer>");
00255 
00256   set_name(scheme_special_comment_type, "<special-comment>");
00257 
00258   set_name(scheme_certifications_type, "<certifications>");
00259 
00260   set_name(scheme_global_ref_type, "<variable-reference>");
00261 
00262   set_name(scheme_delay_syntax_type, "<on-demand-stub>");
00263 
00264   set_name(scheme_intdef_context_type, "<internal-definition-context>");
00265   set_name(scheme_lexical_rib_type, "<internal:lexical-rib>");
00266 
00267   set_name(scheme_already_comp_type, "<internal:already-compiled>");
00268 
00269   set_name(scheme_logger_type, "<logger>");
00270   set_name(scheme_log_reader_type, "<log-receiver>");
00271 
00272   set_name(_scheme_values_types_, "<resurrected>");
00273   set_name(_scheme_compiled_values_types_, "<internal>");
00274 
00275 #ifdef MZ_GC_BACKTRACE
00276   set_name(scheme_rt_meta_cont, "<meta-continuation>");
00277 #endif
00278   set_name(scheme_place_type, "<place>");
00279   set_name(scheme_engine_type, "<engine>");
00280 }
00281 
00282 Scheme_Type scheme_make_type(const char *name)
00283 {
00284   if (!type_names)
00285     init_type_arrays();
00286 
00287   if (maxtype == allocmax) {
00288     /* Expand arrays */
00289     void *naya;
00290     long n;
00291     
00292     allocmax += 20;
00293 
00294     naya = scheme_malloc(allocmax * sizeof(char *));
00295     memcpy(naya, type_names, maxtype * sizeof(char *));
00296     type_names = (char **)naya;
00297 
00298     naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Type_Reader));
00299     memset((char *)naya, 0, n);
00300     memcpy(naya, scheme_type_readers, maxtype * sizeof(Scheme_Type_Reader));
00301     scheme_type_readers = (Scheme_Type_Reader *)naya;
00302 
00303     naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Type_Writer));
00304     memset((char *)naya, 0, n);
00305     memcpy(naya, scheme_type_writers, maxtype * sizeof(Scheme_Type_Writer));
00306     scheme_type_writers = (Scheme_Type_Writer *)naya;
00307 
00308     naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Equal_Proc));
00309     memset((char *)naya, 0, n);
00310     memcpy(naya, scheme_type_equals, maxtype * sizeof(Scheme_Equal_Proc));
00311     scheme_type_equals = (Scheme_Equal_Proc *)naya;
00312 
00313     naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Primary_Hash_Proc));
00314     memset((char *)naya, 0, n);
00315     memcpy(naya, scheme_type_hash1s, maxtype * sizeof(Scheme_Primary_Hash_Proc));
00316     scheme_type_hash1s = (Scheme_Primary_Hash_Proc *)naya;
00317 
00318     naya = scheme_malloc_atomic(n = allocmax * sizeof(Scheme_Secondary_Hash_Proc));
00319     memset((char *)naya, 0, n);
00320     memcpy(naya, scheme_type_hash2s, maxtype * sizeof(Scheme_Secondary_Hash_Proc));
00321     scheme_type_hash2s = (Scheme_Secondary_Hash_Proc *)naya;
00322 
00323 #ifdef MEMORY_COUNTING_ON
00324     scheme_type_table_count += 20 * (sizeof(Scheme_Type_Reader)
00325                                      + sizeof(Scheme_Type_Writer));
00326     scheme_misc_count += (20 * sizeof(char *));
00327 #endif
00328   }
00329 
00330   {
00331     char *tn;
00332     tn = scheme_strdup(name);
00333     type_names[maxtype] = tn;
00334   }
00335 
00336   return maxtype++;
00337 }
00338 
00339 char *scheme_get_type_name(Scheme_Type t)
00340 {
00341   if (t < 0 || t >= maxtype)
00342     return "<bad-value>";
00343   return type_names[t];
00344 }
00345 
00346 void scheme_install_type_reader(Scheme_Type t, Scheme_Type_Reader f)
00347 {
00348   if (t < 0 || t >= maxtype)
00349     return;
00350 
00351   scheme_type_readers[t] = f;
00352 }
00353 
00354 void scheme_install_type_writer(Scheme_Type t, Scheme_Type_Writer f)
00355 {
00356   if (t < 0 || t >= maxtype)
00357     return;
00358 
00359   scheme_type_writers[t] = f;
00360 }
00361 
00362 
00363 void scheme_set_type_equality(Scheme_Type t, 
00364                               Scheme_Equal_Proc f,
00365                               Scheme_Primary_Hash_Proc hash1,
00366                               Scheme_Secondary_Hash_Proc hash2)
00367 {
00368   if (t < 0 || t >= maxtype)
00369     return;
00370 
00371   scheme_type_equals[t] = f;
00372   scheme_type_hash1s[t] = hash1;
00373   scheme_type_hash2s[t] = hash2;
00374 }
00375 
00376 int scheme_num_types(void)
00377 {
00378   return maxtype;
00379 }
00380 
00381 /***********************************************************************/
00382 
00383 #ifdef MZ_PRECISE_GC
00384 
00385 START_XFORM_SKIP;
00386 
00387 static int bad_trav_SIZE(void *p)
00388 {
00389   printf("Shouldn't get here.\n");
00390   exit(1);
00391 }
00392 
00393 static int bad_trav_MARK(void *p)
00394 {
00395   printf("Shouldn't get here.\n");
00396   exit(1);
00397 }
00398 
00399 static int bad_trav_FIXUP(void *p)
00400 {
00401   printf("Shouldn't get here.\n");
00402   exit(1);
00403 }
00404 
00405 #define bad_trav_IS_CONST_SIZE 0
00406 #define bad_trav_IS_ATOMIC 0
00407 
00408 static void MARK_cjs(Scheme_Continuation_Jump_State *cjs)
00409 {
00410   gcMARK(cjs->jumping_to_continuation);
00411   gcMARK(cjs->val);
00412 }
00413 
00414 static void FIXUP_cjs(Scheme_Continuation_Jump_State *cjs)
00415 {
00416   gcFIXUP(cjs->jumping_to_continuation);
00417   gcFIXUP(cjs->val);
00418 }
00419 
00420 static void MARK_stack_state(Scheme_Stack_State *ss)
00421 {
00422 }
00423 
00424 static void FIXUP_stack_state(Scheme_Stack_State *ss)
00425 {
00426 }
00427 
00428 static void MARK_jmpup(Scheme_Jumpup_Buf *buf)
00429 {
00430   gcMARK(buf->stack_copy);
00431   gcMARK(buf->cont);
00432   gcMARK(buf->external_stack);
00433 
00434   /* IMPORTANT: the buf->stack_copy pointer must be the only instance
00435      of this stack to be traversed. If you copy a jmpup buffer (as in
00436      fun.c), don't let a GC happen until the old copy is zeroed
00437      out. */
00438   if (buf->stack_copy)
00439     GC_mark_variable_stack(buf->gc_var_stack,
00440                         (long)buf->stack_copy - (long)buf->stack_from,
00441                         /* FIXME: stack direction */
00442                         (char *)buf->stack_copy + buf->stack_size,
00443                            buf->stack_copy);
00444 }
00445 
00446 static void FIXUP_jmpup(Scheme_Jumpup_Buf *buf)
00447 {
00448   void *new_stack;
00449 
00450   new_stack = GC_resolve(buf->stack_copy);
00451   gcFIXUP_TYPED_NOW(void *, buf->stack_copy);
00452   gcFIXUP(buf->cont);
00453   gcFIXUP(buf->external_stack);
00454 
00455   if (buf->stack_copy)
00456     GC_fixup_variable_stack(buf->gc_var_stack,
00457                          (long)new_stack - (long)buf->stack_from,
00458                          /* FIXME: stack direction */
00459                          (char *)new_stack + buf->stack_size,
00460                             new_stack);
00461 }
00462 
00463 #define RUNSTACK_ZERO_VAL NULL
00464 
00465 #define MARKS_FOR_TYPE_C
00466 #include "mzmark.c"
00467 
00468 void scheme_register_traversers(void)
00469 {
00470   GC_REG_TRAV(scheme_toplevel_type, toplevel_obj);
00471   GC_REG_TRAV(scheme_variable_type, variable_obj);
00472   GC_REG_TRAV(scheme_local_type, local_obj);
00473   GC_REG_TRAV(scheme_local_unbox_type, local_obj);
00474   GC_REG_TRAV(scheme_syntax_type, iptr_obj);
00475   GC_REG_TRAV(scheme_application_type, app_rec);
00476   GC_REG_TRAV(scheme_application2_type, app2_rec);
00477   GC_REG_TRAV(scheme_application3_type, app3_rec);
00478   GC_REG_TRAV(scheme_sequence_type, seq_rec);
00479   GC_REG_TRAV(scheme_branch_type, branch_rec);
00480   GC_REG_TRAV(scheme_unclosed_procedure_type, unclosed_proc);
00481   GC_REG_TRAV(scheme_let_value_type, let_value);
00482   GC_REG_TRAV(scheme_let_void_type, let_void);
00483   GC_REG_TRAV(scheme_letrec_type, letrec);
00484   GC_REG_TRAV(scheme_let_one_type, let_one);
00485   GC_REG_TRAV(scheme_with_cont_mark_type, with_cont_mark);
00486   GC_REG_TRAV(scheme_quote_syntax_type, quotesyntax_obj);
00487   GC_REG_TRAV(scheme_module_variable_type, module_var);
00488 
00489   GC_REG_TRAV(_scheme_values_types_, bad_trav);
00490   
00491   GC_REG_TRAV(scheme_compiled_unclosed_procedure_type, unclosed_proc);
00492   GC_REG_TRAV(scheme_compiled_let_value_type, comp_let_value);
00493   GC_REG_TRAV(scheme_compiled_let_void_type, let_header);
00494   GC_REG_TRAV(scheme_compiled_syntax_type, iptr_obj);
00495   GC_REG_TRAV(scheme_compiled_toplevel_type, toplevel_obj);
00496   GC_REG_TRAV(scheme_compiled_quote_syntax_type, local_obj);
00497 
00498   GC_REG_TRAV(scheme_quote_compilation_type, small_object);
00499 
00500   GC_REG_TRAV(_scheme_compiled_values_types_, bad_trav);
00501 
00502   GC_REG_TRAV(scheme_resolve_prefix_type, resolve_prefix_val);
00503   GC_REG_TRAV(scheme_rt_comp_prefix, comp_prefix_val);
00504 
00505   GC_REG_TRAV(scheme_prim_type, prim_proc);
00506   GC_REG_TRAV(scheme_closed_prim_type, closed_prim_proc);
00507   GC_REG_TRAV(scheme_closure_type, scm_closure);
00508   GC_REG_TRAV(scheme_case_closure_type, case_closure);
00509   GC_REG_TRAV(scheme_cont_type, cont_proc);
00510   GC_REG_TRAV(scheme_rt_dyn_wind, mark_dyn_wind);
00511   GC_REG_TRAV(scheme_rt_overflow, mark_overflow);
00512   GC_REG_TRAV(scheme_rt_overflow_jmp, mark_overflow_jmp);
00513   GC_REG_TRAV(scheme_rt_meta_cont, meta_cont_proc);
00514   GC_REG_TRAV(scheme_escaping_cont_type, escaping_cont_proc);
00515 
00516   GC_REG_TRAV(scheme_char_type, char_obj);
00517   GC_REG_TRAV(scheme_integer_type, bad_trav);
00518   GC_REG_TRAV(scheme_bignum_type, bignum_obj);
00519   GC_REG_TRAV(scheme_rational_type, rational_obj);
00520   GC_REG_TRAV(scheme_float_type,  float_obj);
00521   GC_REG_TRAV(scheme_double_type, double_obj);
00522   GC_REG_TRAV(scheme_complex_type, complex_obj);
00523   GC_REG_TRAV(scheme_char_string_type, string_obj);
00524   GC_REG_TRAV(scheme_byte_string_type, bstring_obj);
00525   GC_REG_TRAV(scheme_unix_path_type, bstring_obj);
00526   GC_REG_TRAV(scheme_windows_path_type, bstring_obj);
00527   GC_REG_TRAV(scheme_symbol_type, symbol_obj);
00528   GC_REG_TRAV(scheme_keyword_type, symbol_obj);
00529   GC_REG_TRAV(scheme_null_type, char_obj); /* small */
00530   GC_REG_TRAV(scheme_pair_type, cons_cell);
00531   GC_REG_TRAV(scheme_mutable_pair_type, cons_cell);
00532   GC_REG_TRAV(scheme_raw_pair_type, cons_cell);
00533   GC_REG_TRAV(scheme_vector_type, vector_obj);
00534   GC_REG_TRAV(scheme_cpointer_type, cpointer_obj);
00535   GC_REG_TRAV(scheme_offset_cpointer_type, offset_cpointer_obj);
00536 
00537   GC_REG_TRAV(scheme_bucket_type, bucket_obj);
00538 
00539   GC_REG_TRAV(scheme_input_port_type, input_port);
00540   GC_REG_TRAV(scheme_output_port_type, output_port);
00541   GC_REG_TRAV(scheme_eof_type, char_obj); /* small */
00542   GC_REG_TRAV(scheme_true_type, char_obj); /* small */
00543   GC_REG_TRAV(scheme_false_type, char_obj); /* small */
00544   GC_REG_TRAV(scheme_void_type, char_obj);  /* small */
00545   GC_REG_TRAV(scheme_syntax_compiler_type, syntax_compiler);
00546   GC_REG_TRAV(scheme_macro_type, small_object);
00547   GC_REG_TRAV(scheme_lazy_macro_type, second_of_cons);
00548   GC_REG_TRAV(scheme_box_type, small_object);
00549   GC_REG_TRAV(scheme_thread_type, thread_val);
00550   GC_REG_TRAV(scheme_prompt_type, prompt_val);
00551   GC_REG_TRAV(scheme_prompt_tag_type, cons_cell);
00552   GC_REG_TRAV(scheme_cont_mark_set_type, cont_mark_set_val);
00553   GC_REG_TRAV(scheme_sema_type, sema_val);
00554   GC_REG_TRAV(scheme_channel_type, channel_val);
00555   GC_REG_TRAV(scheme_channel_put_type, channel_put_val);
00556   GC_REG_TRAV(scheme_semaphore_repost_type, small_object);
00557   GC_REG_TRAV(scheme_thread_suspend_type, twoptr_obj);
00558   GC_REG_TRAV(scheme_thread_resume_type, twoptr_obj);
00559   GC_REG_TRAV(scheme_thread_dead_type, small_object);
00560   GC_REG_TRAV(scheme_hash_table_type, hash_table_val);
00561   GC_REG_TRAV(scheme_bucket_table_type, bucket_table_val);
00562   GC_REG_TRAV(scheme_module_registry_type, hash_table_val);
00563   GC_REG_TRAV(scheme_namespace_type, namespace_val);
00564   GC_REG_TRAV(scheme_random_state_type, random_state_val);
00565   
00566   GC_REG_TRAV(scheme_compilation_top_type, compilation_top_val);
00567   GC_REG_TRAV(scheme_intdef_context_type, twoptr_obj);
00568 
00569   GC_REG_TRAV(scheme_eval_waiting_type, bad_trav);
00570   GC_REG_TRAV(scheme_tail_call_waiting_type, bad_trav);
00571   GC_REG_TRAV(scheme_undefined_type, char_obj); /* small */
00572   GC_REG_TRAV(scheme_placeholder_type, small_object);
00573   GC_REG_TRAV(scheme_table_placeholder_type, iptr_obj);
00574   GC_REG_TRAV(scheme_case_lambda_sequence_type, case_closure);
00575   GC_REG_TRAV(scheme_begin0_sequence_type, seq_rec);
00576 
00577   GC_REG_TRAV(scheme_svector_type, svector_val);
00578 
00579   GC_REG_TRAV(scheme_set_macro_type, small_object);
00580   GC_REG_TRAV(scheme_id_macro_type, twoptr_obj);
00581 
00582   GC_REG_TRAV(scheme_stx_type, stx_val);
00583   GC_REG_TRAV(scheme_stx_offset_type, stx_off_val);
00584   GC_REG_TRAV(scheme_expanded_syntax_type, twoptr_obj);
00585   GC_REG_TRAV(scheme_module_type, module_val);
00586   GC_REG_TRAV(scheme_rt_module_exports, module_exports_val);
00587   GC_REG_TRAV(scheme_module_phase_exports_type, module_phase_exports_val);
00588   GC_REG_TRAV(scheme_module_index_type, modidx_val);
00589 
00590   GC_REG_TRAV(scheme_security_guard_type, guard_val);
00591 
00592   GC_REG_TRAV(scheme_nack_evt_type, twoptr_obj);
00593   GC_REG_TRAV(scheme_always_evt_type, char_obj);
00594   GC_REG_TRAV(scheme_never_evt_type, char_obj);
00595   GC_REG_TRAV(scheme_thread_recv_evt_type, char_obj);
00596 
00597   GC_REG_TRAV(scheme_inspector_type, mark_inspector);
00598 
00599   GC_REG_TRAV(scheme_rt_buf_holder, buf_holder);
00600   GC_REG_TRAV(scheme_rt_pipe, mark_pipe);
00601 
00602   GC_REG_TRAV(scheme_tcp_accept_evt_type, twoptr_obj);
00603 
00604   GC_REG_TRAV(scheme_special_comment_type, small_object);
00605 
00606   GC_REG_TRAV(scheme_progress_evt_type, twoptr_obj);
00607 
00608   GC_REG_TRAV(scheme_already_comp_type, iptr_obj);
00609   
00610   GC_REG_TRAV(scheme_thread_cell_values_type, small_object);
00611 
00612   GC_REG_TRAV(scheme_global_ref_type, small_object);
00613 
00614   GC_REG_TRAV(scheme_delay_syntax_type, small_object);
00615 
00616   GC_REG_TRAV(scheme_resolved_module_path_type, small_object);
00617 
00618   GC_REG_TRAV(scheme_logger_type, mark_logger);
00619   GC_REG_TRAV(scheme_log_reader_type, mark_log_reader);
00620 
00621   GC_REG_TRAV(scheme_rt_runstack, runstack_val);
00622 
00623   GC_REG_TRAV(scheme_rib_delimiter_type, small_object);
00624   GC_REG_TRAV(scheme_noninline_proc_type, small_object);
00625   GC_REG_TRAV(scheme_prune_context_type, small_object);
00626 }
00627 
00628 END_XFORM_SKIP;
00629 
00630 #endif