Esempio n. 1
0
File: bool.c Progetto: SamB/racket
void scheme_init_bool (Scheme_Env *env)
{
  Scheme_Object *p;

  REGISTER_SO(scheme_not_prim);
  REGISTER_SO(scheme_eq_prim);
  REGISTER_SO(scheme_eqv_prim);
  REGISTER_SO(scheme_equal_prim);

  p = scheme_make_folding_prim(not_prim, "not", 1, 1, 1);
  scheme_not_prim = p;
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_OMITABLE);
  scheme_add_global_constant("not", p, env);

  p = scheme_make_folding_prim(boolean_p_prim, "boolean?", 1, 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_OMITABLE);
  scheme_add_global_constant("boolean?", p, env);

  p = scheme_make_folding_prim(eq_prim, "eq?", 2, 2, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_OMITABLE);
  scheme_eq_prim = p;
  scheme_add_global_constant("eq?", p, env);

  p = scheme_make_folding_prim(eqv_prim, "eqv?", 2, 2, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_OMITABLE);
  scheme_eqv_prim = p;
  scheme_add_global_constant("eqv?", scheme_eqv_prim, env);
  
  p = scheme_make_prim_w_arity(equal_prim, "equal?", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_BINARY_INLINED;
  scheme_equal_prim = p;
  scheme_add_global_constant("equal?", scheme_equal_prim, env);

  scheme_add_global_constant("equal?/recur", 
                             scheme_make_prim_w_arity(equalish_prim, "equal?/recur", 3, 3), 
                             env);

  p = scheme_make_immed_prim(chaperone_p, "chaperone?", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_OMITABLE);
  scheme_add_global_constant("chaperone?", p, env);

  p = scheme_make_immed_prim(impersonator_p, "impersonator?", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_OMITABLE);
  scheme_add_global_constant("impersonator?", p, env);

  scheme_add_global_constant("chaperone-of?",
                             scheme_make_prim_w_arity(chaperone_of, "chaperone-of?", 2, 2),
                             env);
  scheme_add_global_constant("impersonator-of?",
                             scheme_make_prim_w_arity(impersonator_of, "impersonator-of?", 2, 2),
                             env);
}
Esempio n. 2
0
void
scheme_init_vector (Scheme_Env *env)
{
    Scheme_Object *p;

    REGISTER_SO(scheme_vector_p_proc);
    p = scheme_make_folding_prim(vector_p, "vector?", 1, 1, 1);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_OMITABLE);
    scheme_add_global_constant("vector?", p, env);
    scheme_vector_p_proc = p;

    REGISTER_SO(scheme_make_vector_proc);
    p = scheme_make_immed_prim(scheme_checked_make_vector, "make-vector", 1, 2);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_BINARY_INLINED);
    scheme_add_global_constant("make-vector", p, env);
    scheme_make_vector_proc = p;

    REGISTER_SO(scheme_vector_proc);
    p = scheme_make_immed_prim(vector, "vector", 0, -1);
    scheme_vector_proc = p;
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_NARY_INLINED
                                 | SCHEME_PRIM_IS_OMITABLE_ALLOCATION);
    scheme_add_global_constant("vector", p, env);

    REGISTER_SO(scheme_vector_immutable_proc);
    p = scheme_make_immed_prim(vector_immutable, "vector-immutable", 0, -1);
    scheme_vector_immutable_proc = p;
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_NARY_INLINED
                                 | SCHEME_PRIM_IS_OMITABLE_ALLOCATION);
    scheme_add_global_constant("vector-immutable", p, env);

    p = scheme_make_folding_prim(vector_length, "vector-length", 1, 1, 1);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_PRODUCES_FIXNUM);
    scheme_add_global_constant("vector-length", p, env);

    REGISTER_SO(scheme_vector_ref_proc);
    p = scheme_make_noncm_prim(scheme_checked_vector_ref,
                               "vector-ref",
                               2, 2);
    scheme_vector_ref_proc = p;
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED);
    scheme_add_global_constant("vector-ref", p, env);

    REGISTER_SO(scheme_vector_set_proc);
    p = scheme_make_noncm_prim(scheme_checked_vector_set,
                               "vector-set!",
                               3, 3);
    scheme_vector_set_proc = p;
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("vector-set!", p, env);

    scheme_add_global_constant("vector->list",
                               scheme_make_immed_prim(vector_to_list,
                                       "vector->list",
                                       1, 1),
                               env);

    REGISTER_SO(scheme_list_to_vector_proc);
    p = scheme_make_immed_prim(list_to_vector,
                               "list->vector",
                               1, 1);
    scheme_list_to_vector_proc = p;
    scheme_add_global_constant("list->vector", p, env);

    scheme_add_global_constant("vector-fill!",
                               scheme_make_immed_prim(vector_fill,
                                       "vector-fill!",
                                       2, 2),
                               env);
    scheme_add_global_constant("vector-copy!",
                               scheme_make_immed_prim(vector_copy_bang,
                                       "vector-copy!",
                                       3, 5),
                               env);
    scheme_add_global_constant("vector->immutable-vector",
                               scheme_make_immed_prim(vector_to_immutable,
                                       "vector->immutable-vector",
                                       1, 1),
                               env);
    scheme_add_global_constant("vector->values",
                               scheme_make_prim_w_arity2(vector_to_values,
                                       "vector->values",
                                       1, 3,
                                       0, -1),
                               env);

    scheme_add_global_constant("chaperone-vector",
                               scheme_make_prim_w_arity(chaperone_vector,
                                       "chaperone-vector",
                                       3, -1),
                               env);
    scheme_add_global_constant("impersonate-vector",
                               scheme_make_prim_w_arity(impersonate_vector,
                                       "impersonate-vector",
                                       3, -1),
                               env);
}
Esempio n. 3
0
File: vector.c Progetto: 4z3/racket
void
scheme_init_unsafe_vector (Scheme_Env *env)
{
  Scheme_Object *p;

  p = scheme_make_immed_prim(unsafe_vector_len, "unsafe-vector-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-vector-length", p, env);

  p = scheme_make_immed_prim(unsafe_vector_len, "unsafe-vector*-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-vector*-length", p, env);

  p = scheme_make_immed_prim(unsafe_vector_ref, "unsafe-vector-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-vector-ref", p, env);

  p = scheme_make_immed_prim(unsafe_vector_ref, "unsafe-vector*-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-vector*-ref", p, env);

  p = scheme_make_immed_prim(unsafe_vector_set, "unsafe-vector-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_NARY_INLINED;
  scheme_add_global_constant("unsafe-vector-set!", p, env);  

  p = scheme_make_immed_prim(unsafe_vector_set, "unsafe-vector*-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_NARY_INLINED;
  scheme_add_global_constant("unsafe-vector*-set!", p, env);  

  p = scheme_make_immed_prim(unsafe_struct_ref, "unsafe-struct-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-struct-ref", p, env);

  p = scheme_make_immed_prim(unsafe_struct_ref, "unsafe-struct*-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-struct*-ref", p, env);

  p = scheme_make_immed_prim(unsafe_struct_set, "unsafe-struct-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_NARY_INLINED;
  scheme_add_global_constant("unsafe-struct-set!", p, env);  

  p = scheme_make_immed_prim(unsafe_struct_set, "unsafe-struct*-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_NARY_INLINED;
  scheme_add_global_constant("unsafe-struct*-set!", p, env);  

  p = scheme_make_immed_prim(unsafe_string_len, "unsafe-string-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-string-length", p, env);

  p = scheme_make_immed_prim(unsafe_string_ref, "unsafe-string-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-string-ref", p, env);

  p = scheme_make_immed_prim(unsafe_string_set, "unsafe-string-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_NARY_INLINED;
  scheme_add_global_constant("unsafe-string-set!", p, env);  

  p = scheme_make_immed_prim(unsafe_bytes_len, "unsafe-bytes-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_UNARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-bytes-length", p, env);

  p = scheme_make_immed_prim(unsafe_bytes_ref, "unsafe-bytes-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= (SCHEME_PRIM_IS_BINARY_INLINED
                                | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL);
  scheme_add_global_constant("unsafe-bytes-ref", p, env);

  p = scheme_make_immed_prim(unsafe_bytes_set, "unsafe-bytes-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_NARY_INLINED;
  scheme_add_global_constant("unsafe-bytes-set!", p, env);
}
Esempio n. 4
0
void
scheme_init_unsafe_vector (Scheme_Env *env)
{
    Scheme_Object *p;

    REGISTER_SO(scheme_unsafe_vector_length_proc);
    p = scheme_make_immed_prim(unsafe_vector_len, "unsafe-vector-length", 1, 1);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                 | SCHEME_PRIM_PRODUCES_FIXNUM);
    scheme_add_global_constant("unsafe-vector-length", p, env);
    scheme_unsafe_vector_length_proc = p;

    p = scheme_make_immed_prim(unsafe_vector_star_len, "unsafe-vector*-length", 1, 1);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                 | SCHEME_PRIM_PRODUCES_FIXNUM);
    scheme_add_global_constant("unsafe-vector*-length", p, env);

    p = scheme_make_immed_prim(unsafe_vector_ref, "unsafe-vector-ref", 2, 2);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                 | SCHEME_PRIM_IS_OMITABLE);
    scheme_add_global_constant("unsafe-vector-ref", p, env);

    p = scheme_make_immed_prim(unsafe_vector_star_ref, "unsafe-vector*-ref", 2, 2);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                 | SCHEME_PRIM_IS_OMITABLE);
    scheme_add_global_constant("unsafe-vector*-ref", p, env);

    p = scheme_make_immed_prim(unsafe_vector_set, "unsafe-vector-set!", 3, 3);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("unsafe-vector-set!", p, env);

    p = scheme_make_immed_prim(unsafe_vector_star_set, "unsafe-vector*-set!", 3, 3);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("unsafe-vector*-set!", p, env);

    REGISTER_SO(scheme_unsafe_struct_ref_proc);
    p = scheme_make_immed_prim(unsafe_struct_ref, "unsafe-struct-ref", 2, 2);
    scheme_unsafe_struct_ref_proc = p;
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                 | SCHEME_PRIM_IS_OMITABLE);
    scheme_add_global_constant("unsafe-struct-ref", p, env);

    p = scheme_make_immed_prim(unsafe_struct_star_ref, "unsafe-struct*-ref", 2, 2);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                 | SCHEME_PRIM_IS_OMITABLE);
    scheme_add_global_constant("unsafe-struct*-ref", p, env);

    p = scheme_make_immed_prim(unsafe_struct_set, "unsafe-struct-set!", 3, 3);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("unsafe-struct-set!", p, env);

    p = scheme_make_immed_prim(unsafe_struct_star_set, "unsafe-struct*-set!", 3, 3);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("unsafe-struct*-set!", p, env);

    REGISTER_SO(scheme_unsafe_string_length_proc);
    p = scheme_make_immed_prim(unsafe_string_len, "unsafe-string-length", 1, 1);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                 | SCHEME_PRIM_PRODUCES_FIXNUM);
    scheme_add_global_constant("unsafe-string-length", p, env);
    scheme_unsafe_string_length_proc = p;

    p = scheme_make_immed_prim(unsafe_string_ref, "unsafe-string-ref", 2, 2);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                 | SCHEME_PRIM_IS_OMITABLE);
    scheme_add_global_constant("unsafe-string-ref", p, env);

    p = scheme_make_immed_prim(unsafe_string_set, "unsafe-string-set!", 3, 3);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("unsafe-string-set!", p, env);

    REGISTER_SO(scheme_unsafe_byte_string_length_proc);
    p = scheme_make_immed_prim(unsafe_bytes_len, "unsafe-bytes-length", 1, 1);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                 | SCHEME_PRIM_PRODUCES_FIXNUM);
    scheme_add_global_constant("unsafe-bytes-length", p, env);
    scheme_unsafe_byte_string_length_proc = p;

    p = scheme_make_immed_prim(unsafe_bytes_ref, "unsafe-bytes-ref", 2, 2);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                 | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                 | SCHEME_PRIM_IS_OMITABLE
                                 | SCHEME_PRIM_PRODUCES_FIXNUM);
    scheme_add_global_constant("unsafe-bytes-ref", p, env);

    p = scheme_make_immed_prim(unsafe_bytes_set, "unsafe-bytes-set!", 3, 3);
    SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
    scheme_add_global_constant("unsafe-bytes-set!", p, env);
}
Esempio n. 5
0
void
scheme_init_unsafe_vector (Scheme_Startup_Env *env)
{
  Scheme_Object *p;

  REGISTER_SO(scheme_unsafe_vector_length_proc);
  p = scheme_make_immed_prim(unsafe_vector_len, "unsafe-vector-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                                            | SCHEME_PRIM_PRODUCES_FIXNUM);
  scheme_addto_prim_instance("unsafe-vector-length", p, env);
  scheme_unsafe_vector_length_proc = p;

  REGISTER_SO(scheme_unsafe_vector_star_length_proc);
  p = scheme_make_immed_prim(unsafe_vector_star_len, "unsafe-vector*-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                                            | SCHEME_PRIM_PRODUCES_FIXNUM);
  scheme_addto_prim_instance("unsafe-vector*-length", p, env);
  scheme_unsafe_vector_star_length_proc = p;

  p = scheme_make_immed_prim(unsafe_vector_ref, "unsafe-vector-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                                            | SCHEME_PRIM_IS_OMITABLE);
  scheme_addto_prim_instance("unsafe-vector-ref", p, env);

  REGISTER_SO(scheme_unsafe_vector_star_ref_proc);
  p = scheme_make_immed_prim(unsafe_vector_star_ref, "unsafe-vector*-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                                            | SCHEME_PRIM_IS_OMITABLE);
  scheme_addto_prim_instance("unsafe-vector*-ref", p, env);
  scheme_unsafe_vector_star_ref_proc = p;

  p = scheme_make_immed_prim(unsafe_vector_set, "unsafe-vector-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-vector-set!", p, env);  

  REGISTER_SO(scheme_unsafe_vector_star_set_proc);
  p = scheme_make_immed_prim(unsafe_vector_star_set, "unsafe-vector*-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-vector*-set!", p, env);
  scheme_unsafe_vector_star_set_proc = p;

  p = scheme_make_immed_prim(unsafe_vector_star_cas, "unsafe-vector*-cas!", 4, 4);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-vector*-cas!", p, env);

  REGISTER_SO(scheme_unsafe_struct_ref_proc);
  p = scheme_make_immed_prim(unsafe_struct_ref, "unsafe-struct-ref", 2, 2);
  scheme_unsafe_struct_ref_proc = p;
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                                            | SCHEME_PRIM_IS_OMITABLE);
  scheme_addto_prim_instance("unsafe-struct-ref", p, env);

  REGISTER_SO(scheme_unsafe_struct_ref_proc);
  p = scheme_make_immed_prim(unsafe_struct_star_ref, "unsafe-struct*-ref", 2, 2);
  scheme_unsafe_struct_star_ref_proc = p;
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                                            | SCHEME_PRIM_IS_OMITABLE);
  scheme_addto_prim_instance("unsafe-struct*-ref", p, env);

  REGISTER_SO(scheme_unsafe_struct_set_proc);
  p = scheme_make_immed_prim(unsafe_struct_set, "unsafe-struct-set!", 3, 3);
  scheme_unsafe_struct_set_proc = p;
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-struct-set!", p, env);

  REGISTER_SO(scheme_unsafe_struct_star_set_proc);
  p = scheme_make_immed_prim(unsafe_struct_star_set, "unsafe-struct*-set!", 3, 3);
  scheme_unsafe_struct_star_set_proc = p;
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-struct*-set!", p, env);

  p = scheme_make_immed_prim(unsafe_struct_star_cas, "unsafe-struct*-cas!", 4, 4);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-struct*-cas!", p, env);

  REGISTER_SO(scheme_unsafe_string_length_proc);
  p = scheme_make_immed_prim(unsafe_string_len, "unsafe-string-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                                            | SCHEME_PRIM_PRODUCES_FIXNUM);
  scheme_addto_prim_instance("unsafe-string-length", p, env);
  scheme_unsafe_string_length_proc = p;

  REGISTER_SO(scheme_unsafe_string_ref_proc);
  p = scheme_make_immed_prim(unsafe_string_ref, "unsafe-string-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                                            | SCHEME_PRIM_IS_OMITABLE);
  scheme_addto_prim_instance("unsafe-string-ref", p, env);
  scheme_unsafe_string_ref_proc = p;

  REGISTER_SO(scheme_unsafe_string_set_proc);
  p = scheme_make_immed_prim(unsafe_string_set, "unsafe-string-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-string-set!", p, env);
  scheme_unsafe_string_set_proc = p;

  REGISTER_SO(scheme_unsafe_byte_string_length_proc);
  p = scheme_make_immed_prim(unsafe_bytes_len, "unsafe-bytes-length", 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_FUNCTIONAL
                                                            | SCHEME_PRIM_PRODUCES_FIXNUM);
  scheme_addto_prim_instance("unsafe-bytes-length", p, env);
  scheme_unsafe_byte_string_length_proc = p;

  REGISTER_SO(scheme_unsafe_bytes_ref_proc);
  p = scheme_make_immed_prim(unsafe_bytes_ref, "unsafe-bytes-ref", 2, 2);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNSAFE_OMITABLE
                                                            | SCHEME_PRIM_IS_OMITABLE
                                                            | SCHEME_PRIM_PRODUCES_FIXNUM);
  scheme_addto_prim_instance("unsafe-bytes-ref", p, env);
  scheme_unsafe_bytes_ref_proc = p;

  REGISTER_SO(scheme_unsafe_bytes_set_proc);
  p = scheme_make_immed_prim(unsafe_bytes_set, "unsafe-bytes-set!", 3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_NARY_INLINED);
  scheme_addto_prim_instance("unsafe-bytes-set!", p, env);
  scheme_unsafe_bytes_set_proc = p;

  scheme_addto_prim_instance("unsafe-impersonate-vector",
			     scheme_make_prim_w_arity(unsafe_impersonate_vector,
						      "unsafe-impersonate-vector",
						      2, -1),
			     env);

  scheme_addto_prim_instance("unsafe-chaperone-vector",
			     scheme_make_prim_w_arity(unsafe_chaperone_vector,
						      "unsafe-chaperone-vector",
						      2, -1),
			     env);
}