Пример #1
0
void scheme_init_numarith(Scheme_Env *env)
{
  Scheme_Object *p;

  p = scheme_make_folding_prim(scheme_add1, "add1", 1, 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED);
  scheme_add_global_constant("add1", p, env);

  p = scheme_make_folding_prim(scheme_sub1, "sub1", 1, 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED);
  scheme_add_global_constant("sub1", p, env);

  p = scheme_make_folding_prim(plus, "+", 0, -1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_NARY_INLINED);
  scheme_add_global_constant("+", p, env);

  p = scheme_make_folding_prim(minus, "-", 1, -1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_UNARY_INLINED
                                                            | SCHEME_PRIM_IS_NARY_INLINED);
  scheme_add_global_constant("-", p, env);

  p = scheme_make_folding_prim(mult, "*", 0, -1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_NARY_INLINED);
  scheme_add_global_constant("*", p, env);

  p = scheme_make_folding_prim(div_prim, "/", 1, -1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED
                                                            | SCHEME_PRIM_IS_NARY_INLINED);
  scheme_add_global_constant("/", p, env);

  p = scheme_make_folding_prim(scheme_abs, "abs", 1, 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED);
  scheme_add_global_constant("abs", p, env);
  
  p = scheme_make_folding_prim(quotient, "quotient", 2, 2, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED);
  scheme_add_global_constant("quotient", p, env);

  p = scheme_make_folding_prim(rem_prim, "remainder", 2, 2, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED);
  scheme_add_global_constant("remainder", p, env);

  scheme_add_global_constant("quotient/remainder", 
			     scheme_make_prim_w_arity2(quotient_remainder,
						       "quotient/remainder", 
						       2, 2,
						       2, 2),
			     env);

  p = scheme_make_folding_prim(scheme_modulo, "modulo", 2, 2, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED);
  scheme_add_global_constant("modulo", p, env);
}
Пример #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);
}
Пример #3
0
void
scheme_init_vector (Scheme_Env *env)
{
  Scheme_Object *p;

  REGISTER_SO(zero_length_vector);
  zero_length_vector = (Scheme_Object *)scheme_malloc_tagged(sizeof(Scheme_Vector)
							     - sizeof(Scheme_Object *));
  zero_length_vector->type = scheme_vector_type;
  SCHEME_VEC_SIZE(zero_length_vector) = 0;

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

  scheme_add_global_constant("make-vector", 
			     scheme_make_noncm_prim(make_vector, 
						    "make-vector", 
						    1, 2), 
			     env);
  scheme_add_global_constant("vector", 
			     scheme_make_noncm_prim(vector, 
						    "vector", 
						    0, -1), 
			     env);
  scheme_add_global_constant("vector-immutable", 
			     scheme_make_noncm_prim(vector_immutable, 
						    "vector-immutable", 
						    0, -1), 
			     env);
  scheme_add_global_constant("vector-length", 
			     scheme_make_folding_prim(vector_length, 
						      "vector-length", 
						      1, 1, 1), 
			     env);

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

  p = scheme_make_noncm_prim(scheme_checked_vector_set,
			     "vector-set!", 
			     3, 3);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_MIN_NARY_INLINED;
  scheme_add_global_constant("vector-set!", p, env);

  scheme_add_global_constant("vector->list", 
			     scheme_make_noncm_prim(vector_to_list, 
						    "vector->list", 
						    1, 1), 
			     env);
  scheme_add_global_constant("list->vector", 
			     scheme_make_noncm_prim(list_to_vector, 
						    "list->vector", 
						    1, 1), 
			     env);
  scheme_add_global_constant("vector-fill!", 
			     scheme_make_noncm_prim(vector_fill, 
						    "vector-fill!", 
						    2, 2), 
			     env);
  scheme_add_global_constant("vector->immutable-vector", 
			     scheme_make_noncm_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);
}