Exemplo n.º 1
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);
}
Exemplo n.º 2
0
void scheme_init_char (Scheme_Env *env)
{
  Scheme_Object *p;
  int i;

  REGISTER_SO(scheme_char_constants);
  REGISTER_SO(general_category_symbols);

  scheme_char_constants = 
    (Scheme_Object **)scheme_malloc_eternal(256 * sizeof(Scheme_Object*));
    
  for (i = 0; i < 256; i++) {
    Scheme_Object *sc;
    sc = scheme_alloc_eternal_small_object();
    sc->type = scheme_char_type;
    SCHEME_CHAR_VAL(sc) = i;
    
    scheme_char_constants[i] = sc;
  }

  p = scheme_make_folding_prim(char_p, "char?", 1, 1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_UNARY_INLINED;
  scheme_add_global_constant("char?", p, env);

  p = scheme_make_folding_prim(char_eq, "char=?", 2, -1, 1);
  SCHEME_PRIM_PROC_FLAGS(p) |= SCHEME_PRIM_IS_BINARY_INLINED;
  scheme_add_global_constant("char=?", p, env);

  scheme_add_global_constant("char<?", 
			     scheme_make_folding_prim(char_lt, 
						      "char<?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char>?", 
			     scheme_make_folding_prim(char_gt, 
						      "char>?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char<=?", 
			     scheme_make_folding_prim(char_lt_eq, 
						      "char<=?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char>=?", 
			     scheme_make_folding_prim(char_gt_eq, 
						      "char>=?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char-ci=?", 
			     scheme_make_folding_prim(char_eq_ci, 
						      "char-ci=?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char-ci<?", 
			     scheme_make_folding_prim(char_lt_ci, 
						      "char-ci<?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char-ci>?", 
			     scheme_make_folding_prim(char_gt_ci, 
						      "char-ci>?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char-ci<=?", 
			     scheme_make_folding_prim(char_lt_eq_ci, 
						      "char-ci<=?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char-ci>=?", 
			     scheme_make_folding_prim(char_gt_eq_ci, 
						      "char-ci>=?", 
						      2, -1, 1), 
			     env);
  scheme_add_global_constant("char-alphabetic?", 
			     scheme_make_folding_prim(char_alphabetic, 
						      "char-alphabetic?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-numeric?", 
			     scheme_make_folding_prim(char_numeric, 
						      "char-numeric?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-symbolic?", 
			     scheme_make_folding_prim(char_symbolic, 
						      "char-symbolic?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-graphic?", 
			     scheme_make_folding_prim(char_graphic, 
						      "char-graphic?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-whitespace?", 
			     scheme_make_folding_prim(char_whitespace, 
						      "char-whitespace?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-blank?", 
			     scheme_make_folding_prim(char_blank, 
						      "char-blank?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-iso-control?", 
			     scheme_make_folding_prim(char_control, 
						      "char-iso-control?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-punctuation?", 
			     scheme_make_folding_prim(char_punctuation, 
						      "char-punctuation?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-upper-case?", 
			     scheme_make_folding_prim(char_upper_case, 
						      "char-upper-case?", 
						      1, 1, 1),
			     env);
  scheme_add_global_constant("char-title-case?", 
			     scheme_make_folding_prim(char_title_case, 
						      "char-title-case?", 
						      1, 1, 1),
			     env);
  scheme_add_global_constant("char-lower-case?", 
			     scheme_make_folding_prim(char_lower_case, 
						      "char-lower-case?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-title-case?", 
			     scheme_make_folding_prim(char_title_case, 
						      "char-title-case?", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char->integer", 
			     scheme_make_folding_prim(char_to_integer, 
						      "char->integer", 
						      1, 1, 1),
			     env);
  scheme_add_global_constant("integer->char",
			     scheme_make_folding_prim(integer_to_char, 
						      "integer->char",
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-upcase", 
			     scheme_make_folding_prim(char_upcase, 
						      "char-upcase", 
						      1, 1, 1), 
			     env);
  scheme_add_global_constant("char-downcase", 
			     scheme_make_folding_prim(char_downcase, 
						      "char-downcase", 
						      1, 1, 1),
			     env);
  scheme_add_global_constant("char-titlecase", 
			     scheme_make_folding_prim(char_titlecase, 
						      "char-titlecase", 
						      1, 1, 1),
			     env);
  scheme_add_global_constant("char-foldcase", 
			     scheme_make_folding_prim(char_foldcase, 
						      "char-foldcase", 
						      1, 1, 1),
			     env);
  scheme_add_global_constant("char-general-category", 
			     scheme_make_folding_prim(char_general_category, 
						      "char-general-category", 
						      1, 1, 1),
			     env);

  scheme_add_global_constant("char-utf-8-length", 
			     scheme_make_folding_prim(char_utf8_length, 
						      "char-utf-8-length", 
						      1, 1, 1),
			     env);

  scheme_add_global_constant("make-known-char-range-list", 
			     scheme_make_noncm_prim(char_map_list, 
						    "make-known-char-range-list", 
						    0, 0),
			     env);
}
Exemplo n.º 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);
}