diff options
Diffstat (limited to 'src/class.c')
| -rw-r--r-- | src/class.c | 757 |
1 files changed, 623 insertions, 134 deletions
diff --git a/src/class.c b/src/class.c index fcbdadea8..bbf64e8ea 100644 --- a/src/class.c +++ b/src/class.c @@ -18,47 +18,266 @@ #include <mruby/istruct.h> #include <mruby/opcode.h> -KHASH_DEFINE(mt, mrb_sym, mrb_method_t, TRUE, kh_int_hash_func, kh_int_hash_equal) +union mt_ptr { + struct RProc *proc; + mrb_func_t func; +}; + +struct mt_elem { + union mt_ptr ptr; + size_t func_p:1; + mrb_sym key:sizeof(mrb_sym)*8-1; +}; + +/* method table structure */ +typedef struct mt_tbl { + size_t size; + size_t alloc; + struct mt_elem *table; +} mt_tbl; + +/* Creates the method table. */ +static mt_tbl* +mt_new(mrb_state *mrb) +{ + mt_tbl *t; + + t = (mt_tbl*)mrb_malloc(mrb, sizeof(mt_tbl)); + t->size = 0; + t->alloc = 0; + t->table = NULL; + + return t; +} + +static struct mt_elem *mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr); + +static void +mt_rehash(mrb_state *mrb, mt_tbl *t) +{ + size_t old_alloc = t->alloc; + size_t new_alloc = old_alloc+1; + struct mt_elem *old_table = t->table; + + khash_power2(new_alloc); + if (old_alloc == new_alloc) return; + + t->alloc = new_alloc; + t->size = 0; + t->table = (struct mt_elem*)mrb_calloc(mrb, sizeof(struct mt_elem), new_alloc); + + for (size_t i = 0; i < old_alloc; i++) { + struct mt_elem *slot = &old_table[i]; + + /* key = 0 means empty or deleted */ + if (slot->key != 0) { + mt_put(mrb, t, slot->key, slot->func_p, slot->ptr); + } + } + mrb_free(mrb, old_table); +} + +#define slot_empty_p(slot) ((slot)->key == 0 && (slot)->func_p == 0) + +/* Set the value for the symbol in the method table. */ +static struct mt_elem* +mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr) +{ + size_t hash, pos, start; + struct mt_elem *dslot = NULL; + + if (t->alloc == 0) { + mt_rehash(mrb, t); + } + hash = kh_int_hash_func(mrb, sym); + start = pos = hash & (t->alloc-1); + for (;;) { + struct mt_elem *slot = &t->table[pos]; + + if (slot->key == sym) { + slot->func_p = func_p; + slot->ptr = ptr; + return slot; + } + else if (slot->key == 0) { /* empty or deleted */ + if (slot->func_p == 0) { /* empty */ + t->size++; + slot->key = sym; + slot->func_p = func_p; + slot->ptr = ptr; + return slot; + } + else if (!dslot) { /* deleted */ + dslot = slot; + } + } + pos = (pos+1) & (t->alloc-1); + if (pos == start) { /* not found */ + if (dslot) { + t->size++; + dslot->key = sym; + dslot->func_p = func_p; + dslot->ptr = ptr; + return dslot; + } + /* no room */ + mt_rehash(mrb, t); + start = pos = hash & (t->alloc-1); + } + } +} + +/* Get a value for a symbol from the method table. */ +static struct mt_elem* +mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym) +{ + size_t hash, pos, start; + + if (t == NULL) return NULL; + if (t->alloc == 0) return NULL; + if (t->size == 0) return NULL; + + hash = kh_int_hash_func(mrb, sym); + start = pos = hash & (t->alloc-1); + for (;;) { + struct mt_elem *slot = &t->table[pos]; + + if (slot->key == sym) { + return slot; + } + else if (slot_empty_p(slot)) { + return NULL; + } + pos = (pos+1) & (t->alloc-1); + if (pos == start) { /* not found */ + return NULL; + } + } +} + +/* Deletes the value for the symbol from the method table. */ +static mrb_bool +mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym) +{ + size_t hash, pos, start; + + if (t == NULL) return FALSE; + if (t->alloc == 0) return FALSE; + if (t->size == 0) return FALSE; + + hash = kh_int_hash_func(mrb, sym); + start = pos = hash & (t->alloc-1); + for (;;) { + struct mt_elem *slot = &t->table[pos]; + + if (slot->key == sym) { + t->size--; + slot->key = 0; + slot->func_p = 1; + return TRUE; + } + else if (slot_empty_p(slot)) { + return FALSE; + } + pos = (pos+1) & (t->alloc-1); + if (pos == start) { /* not found */ + return FALSE; + } + } +} + +/* Copy the method table. */ +static struct mt_tbl* +mt_copy(mrb_state *mrb, mt_tbl *t) +{ + mt_tbl *t2; + size_t i; + + if (t == NULL) return NULL; + if (t->alloc == 0) return NULL; + if (t->size == 0) return NULL; + + t2 = mt_new(mrb); + for (i=0; i<t->alloc; i++) { + struct mt_elem *slot = &t->table[i]; + + if (slot->key) { + mt_put(mrb, t2, slot->key, slot->func_p, slot->ptr); + } + } + return t2; +} + +/* Free memory of the method table. */ +static void +mt_free(mrb_state *mrb, mt_tbl *t) +{ + mrb_free(mrb, t->table); + mrb_free(mrb, t); +} + +MRB_API void +mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *p) +{ + mt_tbl *t = c->mt; + size_t i; + + if (t == NULL) return; + if (t->alloc == 0) return; + if (t->size == 0) return; + + for (i=0; i<t->alloc; i++) { + struct mt_elem *slot = &t->table[i]; + + if (slot->key) { + if (fn(mrb, slot->key, slot, p) != 0) + return; + } + } + return; +} void mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c) { - khiter_t k; - khash_t(mt) *h = c->mt; + mt_tbl *t = c->mt; + size_t i; - if (!h) return; - for (k = kh_begin(h); k != kh_end(h); k++) { - if (kh_exist(h, k)) { - mrb_method_t m = kh_value(h, k); + if (t == NULL) return; + if (t->alloc == 0) return; + if (t->size == 0) return; - if (MRB_METHOD_PROC_P(m)) { - struct RProc *p = MRB_METHOD_PROC(m); - mrb_gc_mark(mrb, (struct RBasic*)p); - } + for (i=0; i<t->alloc; i++) { + struct mt_elem *slot = &t->table[i]; + + if (slot->key && !slot->func_p) { /* Proc pointer */ + struct RProc *p = slot->ptr.proc; + mrb_gc_mark(mrb, (struct RBasic*)p); } } + return; } size_t mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c) { - khash_t(mt) *h = c->mt; + struct mt_tbl *h = c->mt; if (!h) return 0; - return kh_size(h); + return h->size; } void mrb_gc_free_mt(mrb_state *mrb, struct RClass *c) { - kh_destroy(mt, mrb, c->mt); + if (c->mt) mt_free(mrb, c->mt); } void mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb_sym id) { mrb_value name; - mrb_sym nsym = mrb_intern_lit(mrb, "__classname__"); + mrb_sym nsym = MRB_SYM(__classname__); if (mrb_obj_iv_defined(mrb, (struct RObject*)c, nsym)) return; if (outer == NULL || outer == mrb->object_class) { @@ -68,7 +287,7 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb name = mrb_class_path(mrb, outer); if (mrb_nil_p(name)) { /* unnamed outer class */ if (outer != mrb->object_class && outer != c) { - mrb_obj_iv_set_force(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"), + mrb_obj_iv_set_force(mrb, (struct RObject*)c, MRB_SYM(__outer__), mrb_obj_value(outer)); } return; @@ -107,7 +326,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o) if (o->c->tt == MRB_TT_SCLASS) return; sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class); sc->flags |= MRB_FL_CLASS_IS_INHERITED; - sc->mt = kh_init(mt, mrb); + sc->mt = mt_new(mrb); sc->iv = 0; if (o->tt == MRB_TT_CLASS) { c = (struct RClass*)o; @@ -132,7 +351,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o) o->c = sc; mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc); mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o); - mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern_lit(mrb, "__attached__"), mrb_obj_value(o)); + mrb_obj_iv_set(mrb, (struct RObject*)sc, MRB_SYM(__attached__), mrb_obj_value(o)); sc->flags |= o->flags & MRB_FL_OBJ_IS_FROZEN; } @@ -230,6 +449,15 @@ mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id) } MRB_API struct RClass* +mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name) +{ + struct RClass * c = define_module(mrb, name, outer); + + setup_class(mrb, outer, c, name); + return c; +} + +MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name) { mrb_sym id = mrb_intern_cstr(mrb, name); @@ -283,12 +511,10 @@ mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super) } static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value); -#ifdef MRB_METHOD_CACHE -static void mc_clear_all(mrb_state *mrb); -static void mc_clear_by_id(mrb_state *mrb, struct RClass*, mrb_sym); +#ifndef MRB_NO_METHOD_CACHE +static void mc_clear(mrb_state *mrb); #else -#define mc_clear_all(mrb) -#define mc_clear_by_id(mrb,c,s) +#define mc_clear(mrb) #endif static void @@ -302,7 +528,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass) super->flags |= MRB_FL_CLASS_IS_INHERITED; s = mrb_obj_value(super); mrb_mc_clear_by_class(mrb, klass); - mid = mrb_intern_lit(mrb, "inherited"); + mid = MRB_SYM(inherited); if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) { mrb_value c = mrb_obj_value(klass); mrb_funcall_argv(mrb, s, mid, 1, &c); @@ -349,21 +575,29 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name) { - mrb_value sym = mrb_check_intern_cstr(mrb, name); - if (mrb_nil_p(sym)) { - return FALSE; - } - return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym)); + mrb_sym sym = mrb_intern_check_cstr(mrb, name); + if (!sym) return FALSE; + return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), sym); +} + +MRB_API mrb_bool +mrb_class_defined_id(mrb_state *mrb, mrb_sym name) +{ + return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), name); } MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name) { - mrb_value sym = mrb_check_intern_cstr(mrb, name); - if (mrb_nil_p(sym)) { - return FALSE; - } - return mrb_const_defined_at(mrb, mrb_obj_value(outer), mrb_symbol(sym)); + mrb_sym sym = mrb_intern_check_cstr(mrb, name); + if (!sym) return FALSE; + return mrb_const_defined_at(mrb, mrb_obj_value(outer), sym); +} + +MRB_API mrb_bool +mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name) +{ + return mrb_const_defined_at(mrb, mrb_obj_value(outer), name); } MRB_API struct RClass* @@ -373,17 +607,28 @@ mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name) } MRB_API struct RClass* +mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name) +{ + return class_from_sym(mrb, outer, name); +} + +MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name) { return mrb_class_get_under(mrb, mrb->object_class, name); } MRB_API struct RClass* -mrb_exc_get(mrb_state *mrb, const char *name) +mrb_class_get_id(mrb_state *mrb, mrb_sym name) +{ + return mrb_class_get_under_id(mrb, mrb->object_class, name); +} + +MRB_API struct RClass* +mrb_exc_get_id(mrb_state *mrb, mrb_sym name) { struct RClass *exc, *e; - mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), - mrb_intern_cstr(mrb, name)); + mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), name); if (!mrb_class_p(c)) { mrb_raise(mrb, mrb->eException_class, "exception corrupted"); @@ -405,11 +650,23 @@ mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name) } MRB_API struct RClass* +mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name) +{ + return module_from_sym(mrb, outer, name); +} + +MRB_API struct RClass* mrb_module_get(mrb_state *mrb, const char *name) { return mrb_module_get_under(mrb, mrb->object_class, name); } +MRB_API struct RClass* +mrb_module_get_id(mrb_state *mrb, mrb_sym name) +{ + return mrb_module_get_under_id(mrb, mrb->object_class, name); +} + /*! * Defines a class under the namespace of \a outer. * \param outer a class which contains the new class. @@ -427,9 +684,8 @@ mrb_module_get(mrb_state *mrb, const char *name) * \a super, the function just returns the defined class. */ MRB_API struct RClass* -mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super) +mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super) { - mrb_sym id = mrb_intern_cstr(mrb, name); struct RClass * c; #if 0 @@ -437,34 +693,45 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s mrb_warn(mrb, "no super class for '%C::%n', Object assumed", outer, id); } #endif - c = define_class(mrb, id, super, outer); - setup_class(mrb, outer, c, id); + c = define_class(mrb, name, super, outer); + setup_class(mrb, outer, c, name); return c; } +MRB_API struct RClass* +mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super) +{ + return mrb_define_class_under_id(mrb, outer, mrb_intern_cstr(mrb, name), super); +} + MRB_API void mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_t m) { - khash_t(mt) *h; - khiter_t k; + mt_tbl *h; + union mt_ptr ptr; + MRB_CLASS_ORIGIN(c); h = c->mt; - mrb_check_frozen(mrb, c); - if (!h) h = c->mt = kh_init(mt, mrb); - k = kh_put(mt, mrb, h, mid); - kh_value(h, k) = m; - if (MRB_METHOD_PROC_P(m) && !MRB_METHOD_UNDEF_P(m)) { + if (!h) h = c->mt = mt_new(mrb); + if (MRB_METHOD_PROC_P(m)) { struct RProc *p = MRB_METHOD_PROC(m); - p->flags |= MRB_PROC_SCOPE; - p->c = NULL; - mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p); - if (!MRB_PROC_ENV_P(p)) { - MRB_PROC_SET_TARGET_CLASS(p, c); + ptr.proc = p; + if (p) { + p->flags |= MRB_PROC_SCOPE; + p->c = NULL; + mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p); + if (!MRB_PROC_ENV_P(p)) { + MRB_PROC_SET_TARGET_CLASS(p, c); + } } } - mc_clear_by_id(mrb, c, mid); + else { + ptr.func = MRB_METHOD_FUNC(m); + } + mt_put(mrb, h, mid, MRB_METHOD_FUNC_P(m), ptr); + mc_clear(mrb); } MRB_API void @@ -474,6 +741,9 @@ mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t f int ai = mrb_gc_arena_save(mrb); MRB_METHOD_FROM_FUNC(m, func); +#ifndef MRB_USE_METHOD_T_STRUCT + mrb_assert(MRB_METHOD_FUNC(m) == func); +#endif if (aspec == MRB_ARGS_NONE()) { MRB_METHOD_NOARG_SET(m); } @@ -588,8 +858,8 @@ void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self); z: String [const char*] NUL terminated string; z! gives NULL for nil a: Array [mrb_value*,mrb_int] Receive two arguments; a! gives (NULL,0) for nil c: Class/Module [strcut RClass*] - f: Fixnum/Float [mrb_float] - i: Fixnum/Float [mrb_int] + f: Integer/Float [mrb_float] + i: Integer/Float [mrb_int] b: boolean [mrb_bool] n: String/Symbol [mrb_sym] d: data [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified; when ! follows, the value may be nil @@ -849,7 +1119,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } } break; -#ifndef MRB_WITHOUT_FLOAT +#ifndef MRB_NO_FLOAT case 'f': { mrb_float *p; @@ -867,7 +1137,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) p = va_arg(ap, mrb_int*); if (i < argc) { - *p = mrb_fixnum(mrb_to_int(mrb, argv[i++])); + *p = mrb_integer(mrb_to_int(mrb, argv[i++])); } } break; @@ -984,7 +1254,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) else { uint32_t kwnum = kwargs->num; uint32_t required = kwargs->required; - const char *const *kname = kwargs->table; + const mrb_sym *kname = kwargs->table; mrb_value *values = kwargs->values; uint32_t j; const uint32_t keyword_max = 40; @@ -994,16 +1264,16 @@ mrb_get_args(mrb_state *mrb, const char *format, ...) } for (j = required; j > 0; j --, kname ++, values ++) { - mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname)); + mrb_value k = mrb_symbol_value(*kname); if (!mrb_hash_key_p(mrb, ksrc, k)) { - mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %s", *kname); + mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %n", *kname); } *values = mrb_hash_delete_key(mrb, ksrc, k); mrb_gc_protect(mrb, *values); } for (j = kwnum - required; j > 0; j --, kname ++, values ++) { - mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname)); + mrb_value k = mrb_symbol_value(*kname); if (mrb_hash_key_p(mrb, ksrc, k)) { *values = mrb_hash_delete_key(mrb, ksrc, k); mrb_gc_protect(mrb, *values); @@ -1057,7 +1327,7 @@ boot_defclass(mrb_state *mrb, struct RClass *super) else { c->super = mrb->object_class; } - c->mt = kh_init(mt, mrb); + c->mt = mt_new(mrb); return c; } @@ -1065,7 +1335,7 @@ static void boot_initmod(mrb_state *mrb, struct RClass *mod) { if (!mod->mt) { - mod->mt = kh_init(mt, mrb); + mod->mt = mt_new(mrb); } } @@ -1129,7 +1399,7 @@ include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, stru skip: m = m->super; } - mc_clear_all(mrb); + mc_clear(mrb); return 0; } @@ -1155,7 +1425,7 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m) origin->super = c->super; c->super = origin; origin->mt = c->mt; - c->mt = kh_init(mt, mrb); + c->mt = mt_new(mrb); mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)origin); c->flags |= MRB_FL_CLASS_IS_PREPENDED; } @@ -1292,8 +1562,8 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v) case MRB_TT_CPTR: return mrb->object_class; case MRB_TT_SYMBOL: - case MRB_TT_FIXNUM: -#ifndef MRB_WITHOUT_FLOAT + case MRB_TT_INTEGER: +#ifndef MRB_NO_FLOAT case MRB_TT_FLOAT: #endif return NULL; @@ -1324,28 +1594,42 @@ mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name, } MRB_API void +mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *o, mrb_sym name, mrb_func_t func, mrb_aspec aspec) +{ + prepare_singleton_class(mrb, (struct RBasic*)o); + mrb_define_method_id(mrb, o->c, name, func, aspec); +} + +MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec) { mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec); } MRB_API void +mrb_define_class_method_id(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_func_t func, mrb_aspec aspec) +{ + mrb_define_singleton_method_id(mrb, (struct RObject*)c, name, func, aspec); +} + +MRB_API void +mrb_define_module_function_id(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_func_t func, mrb_aspec aspec) +{ + mrb_define_class_method_id(mrb, c, name, func, aspec); + mrb_define_method_id(mrb, c, name, func, aspec); +} + +MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec) { - mrb_define_class_method(mrb, c, name, func, aspec); - mrb_define_method(mrb, c, name, func, aspec); + mrb_define_module_function_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec); } -#ifdef MRB_METHOD_CACHE +#ifndef MRB_NO_METHOD_CACHE static void -mc_clear_all(mrb_state *mrb) +mc_clear(mrb_state *mrb) { - struct mrb_cache_entry *mc = mrb->cache; - int i; - - for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) { - mc[i].c = 0; - } + memset(mrb->cache, 0, MRB_METHOD_CACHE_SIZE*sizeof(mrb->cache[0])); } void @@ -1355,7 +1639,7 @@ mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c) int i; if (c->flags & MRB_FL_CLASS_IS_INHERITED) { - mc_clear_all(mrb); + mc_clear(mrb); c->flags &= ~MRB_FL_CLASS_IS_INHERITED; return; } @@ -1363,32 +1647,14 @@ mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c) if (mc[i].c == c) mc[i].c = 0; } } - -static void -mc_clear_by_id(mrb_state *mrb, struct RClass *c, mrb_sym mid) -{ - struct mrb_cache_entry *mc = mrb->cache; - int i; - - if (c->flags & MRB_FL_CLASS_IS_INHERITED) { - mc_clear_all(mrb); - c->flags &= ~MRB_FL_CLASS_IS_INHERITED; - return; - } - for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) { - if (mc[i].c == c || mc[i].mid == mid) - mc[i].c = 0; - } -} #endif MRB_API mrb_method_t mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid) { - khiter_t k; mrb_method_t m; struct RClass *c = *cp; -#ifdef MRB_METHOD_CACHE +#ifndef MRB_NO_METHOD_CACHE struct RClass *oc = c; int h = kh_int_hash_func(mrb, ((intptr_t)oc) ^ mid) & (MRB_METHOD_CACHE_SIZE-1); struct mrb_cache_entry *mc = &mrb->cache[h]; @@ -1400,15 +1666,20 @@ mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid) #endif while (c) { - khash_t(mt) *h = c->mt; + mt_tbl *h = c->mt; if (h) { - k = kh_get(mt, mrb, h, mid); - if (k != kh_end(h)) { - m = kh_value(h, k); - if (MRB_METHOD_UNDEF_P(m)) break; + struct mt_elem *e = mt_get(mrb, h, mid); + if (e) { + if (e->ptr.proc == 0) break; *cp = c; -#ifdef MRB_METHOD_CACHE + if (e->func_p) { + MRB_METHOD_FROM_FUNC(m, e->ptr.func); + } + else { + MRB_METHOD_FROM_PROC(m, e->ptr.proc); + } +#ifndef MRB_NO_METHOD_CACHE mc->c = oc; mc->c0 = c; mc->mid = mid; @@ -1578,7 +1849,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv) mrb_get_args(mrb, "*!&", &argv, &argc, &blk); obj = mrb_instance_alloc(mrb, cv); - init = mrb_intern_lit(mrb, "initialize"); + init = MRB_SYM(initialize); if (!mrb_func_basic_p(mrb, obj, init, mrb_bob_init)) { mrb_funcall_with_block(mrb, obj, init, argc, argv, blk); } @@ -1592,7 +1863,7 @@ mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *arg mrb_sym mid; obj = mrb_instance_alloc(mrb, mrb_obj_value(c)); - mid = mrb_intern_lit(mrb, "initialize"); + mid = MRB_SYM(initialize); if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) { mrb_funcall_argv(mrb, obj, mid, argc, argv); } @@ -1624,7 +1895,7 @@ mrb_class_new_class(mrb_state *mrb, mrb_value cv) super = mrb_obj_value(mrb->object_class); } new_class = mrb_obj_value(mrb_class_new(mrb, mrb_class_ptr(super))); - mid = mrb_intern_lit(mrb, "initialize"); + mid = MRB_SYM(initialize); if (mrb_func_basic_p(mrb, new_class, mid, mrb_class_initialize)) { mrb_class_initialize(mrb, new_class); } @@ -1722,7 +1993,7 @@ MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c) { mrb_value path; - mrb_sym nsym = mrb_intern_lit(mrb, "__classname__"); + mrb_sym nsym = MRB_SYM(__classname__); path = mrb_obj_iv_get(mrb, (struct RObject*)c, nsym); if (mrb_nil_p(path)) { @@ -1827,7 +2098,7 @@ mrb_module_new(mrb_state *mrb) * called with an explicit receiver, as <code>class</code> is also a * reserved word in Ruby. * - * 1.class #=> Fixnum + * 1.class #=> Integer * self.class #=> Object */ @@ -1877,6 +2148,12 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2)); } +MRB_API void +mrb_define_alias_id(mrb_state *mrb, struct RClass *klass, mrb_sym a, mrb_sym b) +{ + mrb_alias_method(mrb, klass, a, b); +} + /* * call-seq: * mod.to_s -> string @@ -1891,7 +2168,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass) { if (mrb_sclass_p(klass)) { - mrb_value v = mrb_iv_get(mrb, klass, mrb_intern_lit(mrb, "__attached__")); + mrb_value v = mrb_iv_get(mrb, klass, MRB_SYM(__attached__)); mrb_value str = mrb_str_new_lit(mrb, "#<Class:"); if (class_ptr_p(v)) { @@ -1927,7 +2204,7 @@ undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a) mrb_define_method_raw(mrb, c, a, m); } -void +MRB_API void mrb_undef_method_id(mrb_state *mrb, struct RClass *c, mrb_sym a) { if (!mrb_obj_respond_to(mrb, c, a)) { @@ -1943,11 +2220,29 @@ mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name) } MRB_API void +mrb_undef_class_method_id(mrb_state *mrb, struct RClass *c, mrb_sym name) +{ + mrb_undef_method_id(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name); +} + +MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name) { mrb_undef_method(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name); } +MRB_API void +mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym mid) +{ + mt_tbl *h; + + MRB_CLASS_ORIGIN(c); + h = c->mt; + + if (h && mt_del(mrb, h, mid)) return; + mrb_name_error(mrb, mid, "method '%n' not defined in %C", mid, c); +} + static mrb_value mrb_mod_undef(mrb_state *mrb, mrb_value mod) { @@ -2207,6 +2502,202 @@ mrb_mod_module_function(mrb_state *mrb, mrb_value mod) return mod; } +static struct RClass* +mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj) +{ + struct RClass *klass = mrb_basic_ptr(obj)->c; + + if (klass->tt != MRB_TT_SCLASS) + return klass; + else { + /* copy singleton(unnamed) class */ + struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class); + + switch (mrb_type(obj)) { + case MRB_TT_CLASS: + case MRB_TT_SCLASS: + break; + default: + clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass)); + break; + } + clone->super = klass->super; + if (klass->iv) { + mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass)); + mrb_obj_iv_set(mrb, (struct RObject*)clone, MRB_SYM(__attached__), obj); + } + if (klass->mt) { + clone->mt = mt_copy(mrb, klass->mt); + } + else { + clone->mt = mt_new(mrb); + } + clone->tt = MRB_TT_SCLASS; + return clone; + } +} + +static void +copy_class(mrb_state *mrb, mrb_value dst, mrb_value src) +{ + struct RClass *dc = mrb_class_ptr(dst); + struct RClass *sc = mrb_class_ptr(src); + /* if the origin is not the same as the class, then the origin and + the current class need to be copied */ + if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) { + struct RClass *c0 = sc->super; + struct RClass *c1 = dc; + + /* copy prepended iclasses */ + while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) { + c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0))); + c1 = c1->super; + c0 = c0->super; + } + c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0))); + c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN; + } + if (sc->mt) { + dc->mt = mt_copy(mrb, sc->mt); + } + else { + dc->mt = mt_new(mrb); + } + dc->super = sc->super; + MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc)); +} + +/* 15.3.1.3.16 */ +static mrb_value +mrb_obj_init_copy(mrb_state *mrb, mrb_value self) +{ + mrb_value orig = mrb_get_arg1(mrb); + + if (mrb_obj_equal(mrb, self, orig)) return self; + if ((mrb_type(self) != mrb_type(orig)) || (mrb_obj_class(mrb, self) != mrb_obj_class(mrb, orig))) { + mrb_raise(mrb, E_TYPE_ERROR, "initialize_copy should take same class object"); + } + return self; +} + +static void +init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj) +{ + switch (mrb_type(obj)) { + case MRB_TT_ICLASS: + copy_class(mrb, dest, obj); + return; + case MRB_TT_CLASS: + case MRB_TT_MODULE: + copy_class(mrb, dest, obj); + mrb_iv_copy(mrb, dest, obj); + mrb_iv_remove(mrb, dest, MRB_SYM(__classname__)); + break; + case MRB_TT_OBJECT: + case MRB_TT_SCLASS: + case MRB_TT_HASH: + case MRB_TT_DATA: + case MRB_TT_EXCEPTION: + mrb_iv_copy(mrb, dest, obj); + break; + case MRB_TT_ISTRUCT: + mrb_istruct_copy(dest, obj); + break; + + default: + break; + } + if (!mrb_func_basic_p(mrb, dest, MRB_SYM(initialize_copy), mrb_obj_init_copy)) { + mrb_funcall_id(mrb, dest, MRB_SYM(initialize_copy), 1, obj); + } +} + +/* 15.3.1.3.8 */ +/* + * call-seq: + * obj.clone -> an_object + * + * Produces a shallow copy of <i>obj</i>---the instance variables of + * <i>obj</i> are copied, but not the objects they reference. Copies + * the frozen state of <i>obj</i>. See also the discussion + * under <code>Object#dup</code>. + * + * class Klass + * attr_accessor :str + * end + * s1 = Klass.new #=> #<Klass:0x401b3a38> + * s1.str = "Hello" #=> "Hello" + * s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello"> + * s2.str[1,4] = "i" #=> "i" + * s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">" + * s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">" + * + * This method may have class-specific behavior. If so, that + * behavior will be documented under the #+initialize_copy+ method of + * the class. + * + * Some Class(True False Nil Symbol Integer Float) Object cannot clone. + */ +MRB_API mrb_value +mrb_obj_clone(mrb_state *mrb, mrb_value self) +{ + struct RObject *p; + mrb_value clone; + + if (mrb_immediate_p(self)) { + return self; + } + if (mrb_sclass_p(self)) { + mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class"); + } + p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self)); + p->c = mrb_singleton_class_clone(mrb, self); + mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)p->c); + clone = mrb_obj_value(p); + init_copy(mrb, clone, self); + p->flags |= mrb_obj_ptr(self)->flags & MRB_FL_OBJ_IS_FROZEN; + + return clone; +} + +/* 15.3.1.3.9 */ +/* + * call-seq: + * obj.dup -> an_object + * + * Produces a shallow copy of <i>obj</i>---the instance variables of + * <i>obj</i> are copied, but not the objects they reference. + * <code>dup</code> copies the frozen state of <i>obj</i>. See also + * the discussion under <code>Object#clone</code>. In general, + * <code>clone</code> and <code>dup</code> may have different semantics + * in descendant classes. While <code>clone</code> is used to duplicate + * an object, including its internal state, <code>dup</code> typically + * uses the class of the descendant object to create the new instance. + * + * This method may have class-specific behavior. If so, that + * behavior will be documented under the #+initialize_copy+ method of + * the class. + */ + +MRB_API mrb_value +mrb_obj_dup(mrb_state *mrb, mrb_value obj) +{ + struct RBasic *p; + mrb_value dup; + + if (mrb_immediate_p(obj)) { + return obj; + } + if (mrb_sclass_p(obj)) { + mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class"); + } + p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj)); + dup = mrb_obj_value(p); + init_copy(mrb, dup, obj); + + return dup; +} + /* implementation of __id__ */ mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self); /* implementation of instance_eval */ @@ -2229,29 +2720,27 @@ static const mrb_code new_iseq[] = { OP_RETURN, 0x0 /* OP_RETURN R0 */ }; +const mrb_sym new_syms[] = { MRB_SYM(allocate), MRB_SYM(initialize) }; +static const mrb_irep new_irep = { + 3, 6, 0, MRB_IREP_STATIC, + new_iseq, NULL, new_syms, NULL, NULL, NULL, + sizeof(new_iseq), 0, 2, 0, 0, +}; + static void init_class_new(mrb_state *mrb, struct RClass *cls) { struct RProc *p; mrb_method_t m; - mrb_irep *new_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep)); - static const mrb_irep mrb_irep_zero = { 0 }; - - *new_irep = mrb_irep_zero; - new_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2); - new_irep->syms[0] = mrb_intern_lit(mrb, "allocate"); - new_irep->syms[1] = mrb_intern_lit(mrb, "initialize"); - new_irep->slen = 2; - new_irep->flags = MRB_ISEQ_NO_FREE; - new_irep->iseq = new_iseq; - new_irep->ilen = sizeof(new_iseq); - new_irep->nregs = 6; - new_irep->nlocals = 3; - p = mrb_proc_new(mrb, new_irep); + + p = mrb_proc_new(mrb, &new_irep); MRB_METHOD_FROM_PROC(m, p); - mrb_define_method_raw(mrb, cls, mrb_intern_lit(mrb, "new"), m); + mrb_define_method_raw(mrb, cls, MRB_SYM(new), m); } +/* implementation of #send method */ +mrb_value mrb_f_send(mrb_state *mrb, mrb_value self); + void mrb_init_class(mrb_state *mrb) { @@ -2273,16 +2762,16 @@ mrb_init_class(mrb_state *mrb) make_metaclass(mrb, cls); /* name basic classes */ - mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob)); - mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj)); - mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod)); - mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls)); + mrb_define_const_id(mrb, bob, MRB_SYM(BasicObject), mrb_obj_value(bob)); + mrb_define_const_id(mrb, obj, MRB_SYM(Object), mrb_obj_value(obj)); + mrb_define_const_id(mrb, obj, MRB_SYM(Module), mrb_obj_value(mod)); + mrb_define_const_id(mrb, obj, MRB_SYM(Class), mrb_obj_value(cls)); /* name each classes */ - mrb_class_name_class(mrb, NULL, bob, mrb_intern_lit(mrb, "BasicObject")); - mrb_class_name_class(mrb, NULL, obj, mrb_intern_lit(mrb, "Object")); /* 15.2.1 */ - mrb_class_name_class(mrb, NULL, mod, mrb_intern_lit(mrb, "Module")); /* 15.2.2 */ - mrb_class_name_class(mrb, NULL, cls, mrb_intern_lit(mrb, "Class")); /* 15.2.3 */ + mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject)); + mrb_class_name_class(mrb, NULL, obj, MRB_SYM(Object)); /* 15.2.1 */ + mrb_class_name_class(mrb, NULL, mod, MRB_SYM(Module)); /* 15.2.2 */ + mrb_class_name_class(mrb, NULL, cls, MRB_SYM(Class)); /* 15.2.3 */ mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class); /* 15.2.17 */ MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC); |