2 ** class.c - Class class
4 ** See Copyright Notice in mruby.h
9 #include <mruby/array.h>
10 #include <mruby/hash.h>
11 #include <mruby/class.h>
12 #include <mruby/numeric.h>
13 #include <mruby/proc.h>
14 #include <mruby/string.h>
15 #include <mruby/variable.h>
16 #include <mruby/error.h>
17 #include <mruby/data.h>
18 #include <mruby/istruct.h>
19 #include <mruby/opcode.h>
21 KHASH_DEFINE(mt, mrb_sym, mrb_method_t, TRUE, kh_int_hash_func, kh_int_hash_equal)
24 mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
27 khash_t(mt) *h = c->mt;
30 for (k = kh_begin(h); k != kh_end(h); k++) {
32 mrb_method_t m = kh_value(h, k);
34 if (MRB_METHOD_PROC_P(m)) {
35 struct RProc *p = MRB_METHOD_PROC(m);
36 mrb_gc_mark(mrb, (struct RBasic*)p);
43 mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c)
45 khash_t(mt) *h = c->mt;
52 mrb_gc_free_mt(mrb_state *mrb, struct RClass *c)
54 kh_destroy(mt, mrb, c->mt);
58 mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb_sym id)
61 mrb_sym nsym = mrb_intern_lit(mrb, "__classname__");
63 if (mrb_obj_iv_defined(mrb, (struct RObject*)c, nsym)) return;
64 if (outer == NULL || outer == mrb->object_class) {
65 name = mrb_symbol_value(id);
68 name = mrb_class_path(mrb, outer);
69 if (mrb_nil_p(name)) { /* unnamed outer class */
70 if (outer != mrb->object_class && outer != c) {
71 mrb_obj_iv_set_force(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"),
72 mrb_obj_value(outer));
78 const char *n = mrb_sym_name_len(mrb, id, &len);
80 mrb_str_cat_lit(mrb, name, "::");
81 mrb_str_cat(mrb, name, n, len);
84 mrb_obj_iv_set_force(mrb, (struct RObject*)c, nsym, name);
88 mrb_const_name_p(mrb_state *mrb, const char *name, mrb_int len)
90 return len > 0 && ISUPPER(name[0]) && mrb_ident_p(name+1, len-1);
94 setup_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb_sym id)
96 mrb_class_name_class(mrb, outer, c, id);
97 mrb_obj_iv_set(mrb, (struct RObject*)outer, id, mrb_obj_value(c));
100 #define make_metaclass(mrb, c) prepare_singleton_class((mrb), (struct RBasic*)(c))
103 prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
105 struct RClass *sc, *c;
107 if (o->c->tt == MRB_TT_SCLASS) return;
108 sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class);
109 sc->flags |= MRB_FL_CLASS_IS_INHERITED;
110 sc->mt = kh_init(mt, mrb);
112 if (o->tt == MRB_TT_CLASS) {
113 c = (struct RClass*)o;
115 sc->super = mrb->class_class;
118 sc->super = c->super->c;
121 else if (o->tt == MRB_TT_SCLASS) {
122 c = (struct RClass*)o;
123 while (c->super->tt == MRB_TT_ICLASS)
125 make_metaclass(mrb, c->super);
126 sc->super = c->super->c;
130 prepare_singleton_class(mrb, (struct RBasic*)sc);
133 mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc);
134 mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o);
135 mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern_lit(mrb, "__attached__"), mrb_obj_value(o));
136 sc->flags |= o->flags & MRB_FL_OBJ_IS_FROZEN;
140 class_name_str(mrb_state *mrb, struct RClass* c)
142 mrb_value path = mrb_class_path(mrb, c);
143 if (mrb_nil_p(path)) {
144 path = c->tt == MRB_TT_MODULE ? mrb_str_new_lit(mrb, "#<Module:") :
145 mrb_str_new_lit(mrb, "#<Class:");
146 mrb_str_cat_str(mrb, path, mrb_ptr_to_str(mrb, c));
147 mrb_str_cat_lit(mrb, path, ">");
152 static struct RClass*
153 class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
155 mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
157 mrb_check_type(mrb, c, MRB_TT_CLASS);
158 return mrb_class_ptr(c);
161 static struct RClass*
162 module_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
164 mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
166 mrb_check_type(mrb, c, MRB_TT_MODULE);
167 return mrb_class_ptr(c);
171 class_ptr_p(mrb_value obj)
173 switch (mrb_type(obj)) {
184 check_if_class_or_module(mrb_state *mrb, mrb_value obj)
186 if (!class_ptr_p(obj)) {
187 mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a class/module", obj);
191 static struct RClass*
192 define_module(mrb_state *mrb, mrb_sym name, struct RClass *outer)
196 if (mrb_const_defined_at(mrb, mrb_obj_value(outer), name)) {
197 return module_from_sym(mrb, outer, name);
199 m = mrb_module_new(mrb);
200 setup_class(mrb, outer, m, name);
205 MRB_API struct RClass*
206 mrb_define_module_id(mrb_state *mrb, mrb_sym name)
208 return define_module(mrb, name, mrb->object_class);
211 MRB_API struct RClass*
212 mrb_define_module(mrb_state *mrb, const char *name)
214 return define_module(mrb, mrb_intern_cstr(mrb, name), mrb->object_class);
218 mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
220 check_if_class_or_module(mrb, outer);
221 if (mrb_const_defined_at(mrb, outer, id)) {
222 mrb_value old = mrb_const_get(mrb, outer, id);
224 if (!mrb_module_p(old)) {
225 mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a module", old);
227 return mrb_class_ptr(old);
229 return define_module(mrb, id, mrb_class_ptr(outer));
232 MRB_API struct RClass*
233 mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
235 mrb_sym id = mrb_intern_cstr(mrb, name);
236 struct RClass * c = define_module(mrb, id, outer);
238 setup_class(mrb, outer, c, id);
242 static struct RClass*
243 find_origin(struct RClass *c)
249 static struct RClass*
250 define_class(mrb_state *mrb, mrb_sym name, struct RClass *super, struct RClass *outer)
254 if (mrb_const_defined_at(mrb, mrb_obj_value(outer), name)) {
255 c = class_from_sym(mrb, outer, name);
257 if (super && mrb_class_real(c->super) != super) {
258 mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for Class %n (%C not %C)",
259 name, c->super, super);
264 c = mrb_class_new(mrb, super);
265 setup_class(mrb, outer, c, name);
270 MRB_API struct RClass*
271 mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
274 mrb_warn(mrb, "no super class for '%n', Object assumed", name);
276 return define_class(mrb, name, super, mrb->object_class);
279 MRB_API struct RClass*
280 mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
282 return mrb_define_class_id(mrb, mrb_intern_cstr(mrb, name), super);
285 static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value);
286 #ifdef MRB_METHOD_CACHE
287 static void mc_clear_all(mrb_state *mrb);
288 static void mc_clear_by_id(mrb_state *mrb, struct RClass*, mrb_sym);
290 #define mc_clear_all(mrb)
291 #define mc_clear_by_id(mrb,c,s)
295 mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass)
301 super = mrb->object_class;
302 super->flags |= MRB_FL_CLASS_IS_INHERITED;
303 s = mrb_obj_value(super);
304 mrb_mc_clear_by_class(mrb, klass);
305 mid = mrb_intern_lit(mrb, "inherited");
306 if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) {
307 mrb_value c = mrb_obj_value(klass);
308 mrb_funcall_argv(mrb, s, mid, 1, &c);
313 mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id)
318 if (!mrb_nil_p(super)) {
319 if (!mrb_class_p(super)) {
320 mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%!v given)", super);
322 s = mrb_class_ptr(super);
327 check_if_class_or_module(mrb, outer);
328 if (mrb_const_defined_at(mrb, outer, id)) {
329 mrb_value old = mrb_const_get(mrb, outer, id);
331 if (!mrb_class_p(old)) {
332 mrb_raisef(mrb, E_TYPE_ERROR, "%!v is not a class", old);
334 c = mrb_class_ptr(old);
336 /* check super class */
337 if (mrb_class_real(c->super) != s) {
338 mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for class %v", old);
343 c = define_class(mrb, id, s, mrb_class_ptr(outer));
344 mrb_class_inherited(mrb, mrb_class_real(c->super), c);
350 mrb_class_defined(mrb_state *mrb, const char *name)
352 mrb_value sym = mrb_check_intern_cstr(mrb, name);
353 if (mrb_nil_p(sym)) {
356 return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym));
360 mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name)
362 mrb_value sym = mrb_check_intern_cstr(mrb, name);
363 if (mrb_nil_p(sym)) {
366 return mrb_const_defined_at(mrb, mrb_obj_value(outer), mrb_symbol(sym));
369 MRB_API struct RClass*
370 mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
372 return class_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
375 MRB_API struct RClass*
376 mrb_class_get(mrb_state *mrb, const char *name)
378 return mrb_class_get_under(mrb, mrb->object_class, name);
381 MRB_API struct RClass*
382 mrb_exc_get(mrb_state *mrb, const char *name)
384 struct RClass *exc, *e;
385 mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class),
386 mrb_intern_cstr(mrb, name));
388 if (!mrb_class_p(c)) {
389 mrb_raise(mrb, mrb->eException_class, "exception corrupted");
391 exc = e = mrb_class_ptr(c);
394 if (e == mrb->eException_class)
398 return mrb->eException_class;
401 MRB_API struct RClass*
402 mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
404 return module_from_sym(mrb, outer, mrb_intern_cstr(mrb, name));
407 MRB_API struct RClass*
408 mrb_module_get(mrb_state *mrb, const char *name)
410 return mrb_module_get_under(mrb, mrb->object_class, name);
414 * Defines a class under the namespace of \a outer.
415 * \param outer a class which contains the new class.
416 * \param name name of the new class
417 * \param super a class from which the new class will derive.
418 * NULL means \c Object class.
419 * \return the created class
420 * \throw TypeError if the constant name \a name is already taken but
421 * the constant is not a \c Class.
422 * \throw NameError if the class is already defined but the class can not
423 * be reopened because its superclass is not \a super.
424 * \post top-level constant named \a name refers the returned class.
426 * \note if a class named \a name is already defined and its superclass is
427 * \a super, the function just returns the defined class.
429 MRB_API struct RClass*
430 mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
432 mrb_sym id = mrb_intern_cstr(mrb, name);
437 mrb_warn(mrb, "no super class for '%C::%n', Object assumed", outer, id);
440 c = define_class(mrb, id, super, outer);
441 setup_class(mrb, outer, c, id);
446 mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_t m)
453 mrb_check_frozen(mrb, c);
454 if (!h) h = c->mt = kh_init(mt, mrb);
455 k = kh_put(mt, mrb, h, mid);
457 if (MRB_METHOD_PROC_P(m) && !MRB_METHOD_UNDEF_P(m)) {
458 struct RProc *p = MRB_METHOD_PROC(m);
460 p->flags |= MRB_PROC_SCOPE;
462 mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p);
463 if (!MRB_PROC_ENV_P(p)) {
464 MRB_PROC_SET_TARGET_CLASS(p, c);
467 mc_clear_by_id(mrb, c, mid);
471 mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec)
474 int ai = mrb_gc_arena_save(mrb);
476 MRB_METHOD_FROM_FUNC(m, func);
477 if (aspec == MRB_ARGS_NONE()) {
478 MRB_METHOD_NOARG_SET(m);
480 mrb_define_method_raw(mrb, c, mid, m);
481 mrb_gc_arena_restore(mrb, ai);
485 mrb_define_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
487 mrb_define_method_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
490 /* a function to raise NotImplementedError with current method name */
492 mrb_notimplement(mrb_state *mrb)
494 mrb_callinfo *ci = mrb->c->ci;
497 mrb_raisef(mrb, E_NOTIMP_ERROR, "%n() function is unimplemented on this machine", ci->mid);
501 /* a function to be replacement of unimplemented method */
503 mrb_notimplement_m(mrb_state *mrb, mrb_value self)
505 mrb_notimplement(mrb);
507 return mrb_nil_value();
511 to_ary(mrb_state *mrb, mrb_value val)
513 mrb_check_type(mrb, val, MRB_TT_ARRAY);
518 to_hash(mrb_state *mrb, mrb_value val)
520 mrb_check_type(mrb, val, MRB_TT_HASH);
524 #define to_sym(mrb, ss) mrb_obj_to_sym(mrb, ss)
527 mrb_get_argc(mrb_state *mrb)
529 mrb_int argc = mrb->c->ci->argc;
532 struct RArray *a = mrb_ary_ptr(mrb->c->stack[1]);
540 mrb_get_argv(mrb_state *mrb)
542 mrb_int argc = mrb->c->ci->argc;
543 mrb_value *array_argv = mrb->c->stack + 1;
545 struct RArray *a = mrb_ary_ptr(*array_argv);
547 array_argv = ARY_PTR(a);
553 mrb_get_arg1(mrb_state *mrb)
555 mrb_int argc = mrb->c->ci->argc;
556 mrb_value *array_argv = mrb->c->stack + 1;
558 struct RArray *a = mrb_ary_ptr(*array_argv);
561 array_argv = ARY_PTR(a);
564 mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
566 return array_argv[0];
569 void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
572 retrieve arguments from mrb_state.
574 mrb_get_args(mrb, format, ...)
576 returns number of arguments parsed.
580 string mruby type C type note
581 ----------------------------------------------------------------------------------------------
582 o: Object [mrb_value]
583 C: Class/Module [mrb_value]
584 S: String [mrb_value] when ! follows, the value may be nil
585 A: Array [mrb_value] when ! follows, the value may be nil
586 H: Hash [mrb_value] when ! follows, the value may be nil
587 s: String [char*,mrb_int] Receive two arguments; s! gives (NULL,0) for nil
588 z: String [char*] NUL terminated string; z! gives NULL for nil
589 a: Array [mrb_value*,mrb_int] Receive two arguments; a! gives (NULL,0) for nil
590 f: Fixnum/Float [mrb_float]
591 i: Fixnum/Float [mrb_int]
592 b: boolean [mrb_bool]
593 n: String/Symbol [mrb_sym]
594 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
595 I: inline struct [void*]
596 &: block [mrb_value] &! raises exception if no block given
597 *: rest argument [mrb_value*,mrb_int] The rest of the arguments as an array; *! avoid copy of the stack
598 |: optional Following arguments are optional
599 ?: optional given [mrb_bool] true if preceding argument (optional) is given
600 ':': keyword args [mrb_kwargs const] Get keyword arguments
603 mrb_get_args(mrb_state *mrb, const char *format, ...)
605 const char *fmt = format;
609 mrb_int argc = mrb->c->ci->argc;
610 mrb_value *array_argv = mrb->c->stack+1;
611 mrb_bool argv_on_stack = argc >= 0;
612 mrb_bool opt = FALSE;
613 mrb_bool opt_skip = TRUE;
614 mrb_bool given = TRUE;
616 mrb_bool reqkarg = FALSE;
617 mrb_int needargc = 0;
619 if (!argv_on_stack) {
620 struct RArray *a = mrb_ary_ptr(*array_argv);
621 array_argv = ARY_PTR(a);
624 va_start(ap, format);
626 #define ARGV array_argv
628 while ((c = *fmt++)) {
635 if (!reqkarg) reqkarg = strchr(fmt, ':') ? TRUE : FALSE;
643 if (opt) opt_skip = FALSE;
646 if (!opt) needargc ++;
652 if (reqkarg && argc > needargc && mrb_hash_p(kdict = ARGV[argc - 1])) {
653 mrb_hash_check_kdict(mrb, kdict);
657 kdict = mrb_nil_value();
662 while ((c = *format++)) {
663 mrb_value *argv = ARGV;
667 case '|': case '*': case '&': case '?': case ':':
675 mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
681 if (*format == '!') {
694 p = va_arg(ap, mrb_value*);
704 p = va_arg(ap, mrb_value*);
709 if (!class_ptr_p(ss)) {
710 mrb_raisef(mrb, E_TYPE_ERROR, "%v is not class/module", ss);
720 p = va_arg(ap, mrb_value*);
723 if (!(altmode && mrb_nil_p(*p))) {
733 p = va_arg(ap, mrb_value*);
736 if (!(altmode && mrb_nil_p(*p))) {
737 *p = to_ary(mrb, *p);
746 p = va_arg(ap, mrb_value*);
749 if (!(altmode && mrb_nil_p(*p))) {
750 *p = to_hash(mrb, *p);
761 ps = va_arg(ap, char**);
762 pl = va_arg(ap, mrb_int*);
765 if (altmode && mrb_nil_p(ss)) {
771 *ps = RSTRING_PTR(ss);
772 *pl = RSTRING_LEN(ss);
782 ps = va_arg(ap, const char**);
785 if (altmode && mrb_nil_p(ss)) {
790 *ps = RSTRING_CSTR(mrb, ss);
802 pb = va_arg(ap, mrb_value**);
803 pl = va_arg(ap, mrb_int*);
806 if (altmode && mrb_nil_p(aa)) {
811 aa = to_ary(mrb, aa);
824 p = va_arg(ap, void**);
827 if (!mrb_istruct_p(ss))
829 mrb_raisef(mrb, E_TYPE_ERROR, "%v is not inline struct", ss);
831 *p = mrb_istruct_ptr(ss);
835 #ifndef MRB_WITHOUT_FLOAT
840 p = va_arg(ap, mrb_float*);
842 *p = mrb_to_flo(mrb, argv[i++]);
851 p = va_arg(ap, mrb_int*);
853 *p = mrb_fixnum(mrb_to_int(mrb, argv[i++]));
859 mrb_bool *boolp = va_arg(ap, mrb_bool*);
862 mrb_value b = argv[i++];
863 *boolp = mrb_test(b);
871 symp = va_arg(ap, mrb_sym*);
876 *symp = to_sym(mrb, ss);
883 struct mrb_data_type const* type;
885 datap = va_arg(ap, void**);
886 type = va_arg(ap, struct mrb_data_type const*);
888 mrb_value dd = argv[i++];
889 if (altmode && mrb_nil_p(dd)) {
893 *datap = mrb_data_get_ptr(mrb, dd, type);
903 p = va_arg(ap, mrb_value*);
904 if (mrb->c->ci->argc < 0) {
905 bp = mrb->c->stack + 2;
908 bp = mrb->c->stack + mrb->c->ci->argc + 1;
910 if (altmode && mrb_nil_p(*bp)) {
911 mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
917 if (opt_skip && i == argc) goto finish;
924 p = va_arg(ap, mrb_bool*);
933 mrb_bool nocopy = (altmode || !argv_on_stack) ? TRUE : FALSE;
935 var = va_arg(ap, mrb_value**);
936 pl = va_arg(ap, mrb_int*);
944 mrb_value args = mrb_ary_new_from_values(mrb, *pl, argv+i);
945 RARRAY(args)->c = NULL;
946 *var = RARRAY_PTR(args);
960 mrb_value ksrc = mrb_hash_p(kdict) ? mrb_hash_dup(mrb, kdict) : mrb_hash_new(mrb);
961 const mrb_kwargs *kwargs = va_arg(ap, const mrb_kwargs*);
964 if (kwargs == NULL) {
968 uint32_t kwnum = kwargs->num;
969 uint32_t required = kwargs->required;
970 const char *const *kname = kwargs->table;
971 mrb_value *values = kwargs->values;
973 const uint32_t keyword_max = 40;
975 if (kwnum > keyword_max || required > kwnum) {
976 mrb_raise(mrb, E_ARGUMENT_ERROR, "keyword number is too large");
979 for (j = required; j > 0; j --, kname ++, values ++) {
980 mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname));
981 if (!mrb_hash_key_p(mrb, ksrc, k)) {
982 mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %s", *kname);
984 *values = mrb_hash_delete_key(mrb, ksrc, k);
985 mrb_gc_protect(mrb, *values);
988 for (j = kwnum - required; j > 0; j --, kname ++, values ++) {
989 mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname));
990 if (mrb_hash_key_p(mrb, ksrc, k)) {
991 *values = mrb_hash_delete_key(mrb, ksrc, k);
992 mrb_gc_protect(mrb, *values);
995 *values = mrb_undef_value();
1005 else if (!mrb_hash_empty_p(mrb, ksrc)) {
1006 ksrc = mrb_hash_keys(mrb, ksrc);
1007 ksrc = RARRAY_PTR(ksrc)[0];
1008 mrb_raisef(mrb, E_ARGUMENT_ERROR, "unknown keyword: %v", ksrc);
1014 mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid argument specifier %c", c);
1021 if (!c && argc > i) {
1022 mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
1030 static struct RClass*
1031 boot_defclass(mrb_state *mrb, struct RClass *super)
1035 c = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_CLASS, mrb->class_class);
1038 mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)super);
1041 c->super = mrb->object_class;
1043 c->mt = kh_init(mt, mrb);
1048 boot_initmod(mrb_state *mrb, struct RClass *mod)
1051 mod->mt = kh_init(mt, mrb);
1055 static struct RClass*
1056 include_class_new(mrb_state *mrb, struct RClass *m, struct RClass *super)
1058 struct RClass *ic = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, mrb->class_class);
1059 if (m->tt == MRB_TT_ICLASS) {
1062 MRB_CLASS_ORIGIN(m);
1066 if (m->tt == MRB_TT_ICLASS) {
1076 include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, struct RClass *m, int search_super)
1078 struct RClass *p, *ic;
1079 void *klass_mt = find_origin(c)->mt;
1082 int superclass_seen = 0;
1084 if (m->flags & MRB_FL_CLASS_IS_PREPENDED)
1087 if (klass_mt && klass_mt == m->mt)
1092 if (p->tt == MRB_TT_ICLASS) {
1093 if (p->mt == m->mt) {
1094 if (!superclass_seen) {
1095 ins_pos = p; /* move insert point */
1099 } else if (p->tt == MRB_TT_CLASS) {
1100 if (!search_super) break;
1101 superclass_seen = 1;
1106 ic = include_class_new(mrb, m, ins_pos->super);
1107 m->flags |= MRB_FL_CLASS_IS_INHERITED;
1108 ins_pos->super = ic;
1109 mrb_field_write_barrier(mrb, (struct RBasic*)ins_pos, (struct RBasic*)ic);
1110 mrb_mc_clear_by_class(mrb, ins_pos);
1120 mrb_include_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
1122 mrb_check_frozen(mrb, c);
1123 if (include_module_at(mrb, c, find_origin(c), m, 1) < 0) {
1124 mrb_raise(mrb, E_ARGUMENT_ERROR, "cyclic include detected");
1129 mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
1131 struct RClass *origin;
1134 mrb_check_frozen(mrb, c);
1135 if (!(c->flags & MRB_FL_CLASS_IS_PREPENDED)) {
1136 origin = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_ICLASS, c);
1137 origin->flags |= MRB_FL_CLASS_IS_ORIGIN | MRB_FL_CLASS_IS_INHERITED;
1138 origin->super = c->super;
1141 c->mt = kh_init(mt, mrb);
1142 mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)origin);
1143 c->flags |= MRB_FL_CLASS_IS_PREPENDED;
1145 changed = include_module_at(mrb, c, c, m, 0);
1147 mrb_raise(mrb, E_ARGUMENT_ERROR, "cyclic prepend detected");
1152 mrb_mod_prepend_features(mrb_state *mrb, mrb_value mod)
1156 mrb_check_type(mrb, mod, MRB_TT_MODULE);
1157 mrb_get_args(mrb, "C", &klass);
1158 mrb_prepend_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
1163 mrb_mod_append_features(mrb_state *mrb, mrb_value mod)
1167 mrb_check_type(mrb, mod, MRB_TT_MODULE);
1168 mrb_get_args(mrb, "C", &klass);
1169 mrb_include_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
1176 * mod.include?(module) -> true or false
1178 * Returns <code>true</code> if <i>module</i> is included in
1179 * <i>mod</i> or one of <i>mod</i>'s ancestors.
1188 * B.include?(A) #=> true
1189 * C.include?(A) #=> true
1190 * A.include?(A) #=> false
1193 mrb_mod_include_p(mrb_state *mrb, mrb_value mod)
1196 struct RClass *c = mrb_class_ptr(mod);
1198 mrb_get_args(mrb, "C", &mod2);
1199 mrb_check_type(mrb, mod2, MRB_TT_MODULE);
1202 if (c->tt == MRB_TT_ICLASS) {
1203 if (c->c == mrb_class_ptr(mod2)) return mrb_true_value();
1207 return mrb_false_value();
1211 mrb_mod_ancestors(mrb_state *mrb, mrb_value self)
1214 struct RClass *c = mrb_class_ptr(self);
1215 result = mrb_ary_new(mrb);
1217 if (c->tt == MRB_TT_ICLASS) {
1218 mrb_ary_push(mrb, result, mrb_obj_value(c->c));
1220 else if (!(c->flags & MRB_FL_CLASS_IS_PREPENDED)) {
1221 mrb_ary_push(mrb, result, mrb_obj_value(c));
1230 mrb_mod_extend_object(mrb_state *mrb, mrb_value mod)
1232 mrb_value obj = mrb_get_arg1(mrb);
1234 mrb_check_type(mrb, mod, MRB_TT_MODULE);
1235 mrb_include_module(mrb, mrb_class_ptr(mrb_singleton_class(mrb, obj)), mrb_class_ptr(mod));
1240 mrb_mod_initialize(mrb_state *mrb, mrb_value mod)
1243 struct RClass *m = mrb_class_ptr(mod);
1244 boot_initmod(mrb, m); /* bootstrap a newly initialized module */
1245 mrb_get_args(mrb, "|&", &b);
1246 if (!mrb_nil_p(b)) {
1247 mrb_yield_with_class(mrb, b, 1, &mod, mod, m);
1252 /* implementation of module_eval/class_eval */
1253 mrb_value mrb_mod_module_eval(mrb_state*, mrb_value);
1256 mrb_mod_dummy_visibility(mrb_state *mrb, mrb_value mod)
1261 /* returns mrb_class_ptr(mrb_singleton_class()) */
1262 /* except that it return NULL for immediate values */
1263 MRB_API struct RClass*
1264 mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v)
1268 switch (mrb_type(v)) {
1271 return mrb->nil_class;
1272 return mrb->false_class;
1274 return mrb->true_class;
1276 return mrb->object_class;
1279 #ifndef MRB_WITHOUT_FLOAT
1286 obj = mrb_basic_ptr(v);
1287 prepare_singleton_class(mrb, obj);
1292 mrb_singleton_class(mrb_state *mrb, mrb_value v)
1294 struct RClass *c = mrb_singleton_class_ptr(mrb, v);
1297 mrb_raise(mrb, E_TYPE_ERROR, "can't define singleton");
1299 return mrb_obj_value(c);
1303 mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name, mrb_func_t func, mrb_aspec aspec)
1305 prepare_singleton_class(mrb, (struct RBasic*)o);
1306 mrb_define_method_id(mrb, o->c, mrb_intern_cstr(mrb, name), func, aspec);
1310 mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
1312 mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec);
1316 mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
1318 mrb_define_class_method(mrb, c, name, func, aspec);
1319 mrb_define_method(mrb, c, name, func, aspec);
1322 #ifdef MRB_METHOD_CACHE
1324 mc_clear_all(mrb_state *mrb)
1326 struct mrb_cache_entry *mc = mrb->cache;
1329 for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
1335 mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c)
1337 struct mrb_cache_entry *mc = mrb->cache;
1340 if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
1342 c->flags &= ~MRB_FL_CLASS_IS_INHERITED;
1345 for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
1346 if (mc[i].c == c) mc[i].c = 0;
1351 mc_clear_by_id(mrb_state *mrb, struct RClass *c, mrb_sym mid)
1353 struct mrb_cache_entry *mc = mrb->cache;
1356 if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
1358 c->flags &= ~MRB_FL_CLASS_IS_INHERITED;
1361 for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
1362 if (mc[i].c == c || mc[i].mid == mid)
1368 MRB_API mrb_method_t
1369 mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
1373 struct RClass *c = *cp;
1374 #ifdef MRB_METHOD_CACHE
1375 struct RClass *oc = c;
1376 int h = kh_int_hash_func(mrb, ((intptr_t)oc) ^ mid) & (MRB_METHOD_CACHE_SIZE-1);
1377 struct mrb_cache_entry *mc = &mrb->cache[h];
1379 if (mc->c == c && mc->mid == mid) {
1386 khash_t(mt) *h = c->mt;
1389 k = kh_get(mt, mrb, h, mid);
1390 if (k != kh_end(h)) {
1392 if (MRB_METHOD_UNDEF_P(m)) break;
1394 #ifdef MRB_METHOD_CACHE
1405 MRB_METHOD_FROM_PROC(m, NULL);
1406 return m; /* no method */
1409 MRB_API mrb_method_t
1410 mrb_method_search(mrb_state *mrb, struct RClass* c, mrb_sym mid)
1414 m = mrb_method_search_vm(mrb, &c, mid);
1415 if (MRB_METHOD_UNDEF_P(m)) {
1416 mrb_name_error(mrb, mid, "undefined method '%n' for class %C", mid, c);
1421 #define ONSTACK_ALLOC_MAX 32
1424 prepare_name_common(mrb_state *mrb, mrb_sym sym, const char *prefix, const char *suffix)
1426 char onstack[ONSTACK_ALLOC_MAX];
1428 const char *sym_str = mrb_sym_name_len(mrb, sym, &sym_len);
1429 size_t prefix_len = prefix ? strlen(prefix) : 0;
1430 size_t suffix_len = suffix ? strlen(suffix) : 0;
1431 size_t name_len = sym_len + prefix_len + suffix_len;
1432 char *buf = name_len > sizeof(onstack) ? (char *)mrb_alloca(mrb, name_len) : onstack;
1435 if (prefix_len > 0) {
1436 memcpy(p, prefix, prefix_len);
1440 memcpy(p, sym_str, sym_len);
1443 if (suffix_len > 0) {
1444 memcpy(p, suffix, suffix_len);
1448 return mrb_intern(mrb, buf, name_len);
1452 prepare_ivar_name(mrb_state *mrb, mrb_sym sym)
1454 sym = prepare_name_common(mrb, sym, "@", NULL);
1455 mrb_iv_name_sym_check(mrb, sym);
1456 return mrb_symbol_value(sym);
1460 prepare_writer_name(mrb_state *mrb, mrb_sym sym)
1462 return prepare_name_common(mrb, sym, NULL, "=");
1466 mod_attr_define(mrb_state *mrb, mrb_value mod, mrb_value (*accessor)(mrb_state *, mrb_value), mrb_sym (*access_name)(mrb_state *, mrb_sym))
1468 struct RClass *c = mrb_class_ptr(mod);
1473 mrb_get_args(mrb, "*", &argv, &argc);
1474 ai = mrb_gc_arena_save(mrb);
1475 for (i=0; i<argc; i++) {
1481 method = to_sym(mrb, argv[i]);
1482 name = prepare_ivar_name(mrb, method);
1484 method = access_name(mrb, method);
1487 p = mrb_proc_new_cfunc_with_env(mrb, accessor, 1, &name);
1488 MRB_METHOD_FROM_PROC(m, p);
1489 mrb_define_method_raw(mrb, c, method, m);
1490 mrb_gc_arena_restore(mrb, ai);
1492 return mrb_nil_value();
1496 attr_reader(mrb_state *mrb, mrb_value obj)
1498 mrb_value name = mrb_proc_cfunc_env_get(mrb, 0);
1499 return mrb_iv_get(mrb, obj, to_sym(mrb, name));
1503 mrb_mod_attr_reader(mrb_state *mrb, mrb_value mod)
1505 return mod_attr_define(mrb, mod, attr_reader, NULL);
1509 attr_writer(mrb_state *mrb, mrb_value obj)
1511 mrb_value name = mrb_proc_cfunc_env_get(mrb, 0);
1512 mrb_value val = mrb_get_arg1(mrb);
1514 mrb_iv_set(mrb, obj, to_sym(mrb, name), val);
1519 mrb_mod_attr_writer(mrb_state *mrb, mrb_value mod)
1521 return mod_attr_define(mrb, mod, attr_writer, prepare_writer_name);
1525 mrb_instance_alloc(mrb_state *mrb, mrb_value cv)
1527 struct RClass *c = mrb_class_ptr(cv);
1529 enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
1531 if (c->tt == MRB_TT_SCLASS)
1532 mrb_raise(mrb, E_TYPE_ERROR, "can't create instance of singleton class");
1534 if (ttype == 0) ttype = MRB_TT_OBJECT;
1535 if (ttype <= MRB_TT_CPTR) {
1536 mrb_raisef(mrb, E_TYPE_ERROR, "can't create instance of %v", cv);
1538 o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
1539 return mrb_obj_value(o);
1544 * class.new(args, ...) -> obj
1546 * Creates a new object of <i>class</i>'s class, then
1547 * invokes that object's <code>initialize</code> method,
1548 * passing it <i>args</i>. This is the method that ends
1549 * up getting called whenever an object is constructed using
1555 mrb_instance_new(mrb_state *mrb, mrb_value cv)
1562 mrb_get_args(mrb, "*!&", &argv, &argc, &blk);
1563 obj = mrb_instance_alloc(mrb, cv);
1564 init = mrb_intern_lit(mrb, "initialize");
1565 if (!mrb_func_basic_p(mrb, obj, init, mrb_bob_init)) {
1566 mrb_funcall_with_block(mrb, obj, init, argc, argv, blk);
1572 mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv)
1577 obj = mrb_instance_alloc(mrb, mrb_obj_value(c));
1578 mid = mrb_intern_lit(mrb, "initialize");
1579 if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) {
1580 mrb_funcall_argv(mrb, obj, mid, argc, argv);
1586 mrb_class_initialize(mrb_state *mrb, mrb_value c)
1590 mrb_get_args(mrb, "|C&", &a, &b);
1591 if (!mrb_nil_p(b)) {
1592 mrb_yield_with_class(mrb, b, 1, &c, c, mrb_class_ptr(c));
1598 mrb_class_new_class(mrb_state *mrb, mrb_value cv)
1601 mrb_value super, blk;
1602 mrb_value new_class;
1605 n = mrb_get_args(mrb, "|C&", &super, &blk);
1607 super = mrb_obj_value(mrb->object_class);
1609 new_class = mrb_obj_value(mrb_class_new(mrb, mrb_class_ptr(super)));
1610 mid = mrb_intern_lit(mrb, "initialize");
1611 if (mrb_func_basic_p(mrb, new_class, mid, mrb_class_initialize)) {
1612 mrb_class_initialize(mrb, new_class);
1615 mrb_funcall_with_block(mrb, new_class, mid, n, &super, blk);
1617 mrb_class_inherited(mrb, mrb_class_ptr(super), mrb_class_ptr(new_class));
1622 mrb_class_superclass(mrb_state *mrb, mrb_value klass)
1626 c = mrb_class_ptr(klass);
1627 c = find_origin(c)->super;
1628 while (c && c->tt == MRB_TT_ICLASS) {
1629 c = find_origin(c)->super;
1631 if (!c) return mrb_nil_value();
1632 return mrb_obj_value(c);
1636 mrb_bob_init(mrb_state *mrb, mrb_value cv)
1638 return mrb_nil_value();
1642 mrb_bob_not(mrb_state *mrb, mrb_value cv)
1644 return mrb_bool_value(!mrb_test(cv));
1652 * obj == other -> true or false
1653 * obj.equal?(other) -> true or false
1654 * obj.eql?(other) -> true or false
1656 * Equality---At the <code>Object</code> level, <code>==</code> returns
1657 * <code>true</code> only if <i>obj</i> and <i>other</i> are the
1658 * same object. Typically, this method is overridden in descendant
1659 * classes to provide class-specific meaning.
1661 * Unlike <code>==</code>, the <code>equal?</code> method should never be
1662 * overridden by subclasses: it is used to determine object identity
1663 * (that is, <code>a.equal?(b)</code> iff <code>a</code> is the same
1664 * object as <code>b</code>).
1666 * The <code>eql?</code> method returns <code>true</code> if
1667 * <i>obj</i> and <i>anObject</i> have the same value. Used by
1668 * <code>Hash</code> to test members for equality. For objects of
1669 * class <code>Object</code>, <code>eql?</code> is synonymous with
1670 * <code>==</code>. Subclasses normally continue this tradition, but
1671 * there are exceptions. <code>Numeric</code> types, for example,
1672 * perform type conversion across <code>==</code>, but not across
1673 * <code>eql?</code>, so:
1676 * 1.eql? 1.0 #=> false
1679 mrb_obj_equal_m(mrb_state *mrb, mrb_value self)
1681 mrb_value arg = mrb_get_arg1(mrb);
1683 return mrb_bool_value(mrb_obj_equal(mrb, self, arg));
1687 mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid)
1691 m = mrb_method_search_vm(mrb, &c, mid);
1692 if (MRB_METHOD_UNDEF_P(m)) {
1699 mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid)
1701 return mrb_obj_respond_to(mrb, mrb_class(mrb, obj), mid);
1705 mrb_class_path(mrb_state *mrb, struct RClass *c)
1708 mrb_sym nsym = mrb_intern_lit(mrb, "__classname__");
1710 path = mrb_obj_iv_get(mrb, (struct RObject*)c, nsym);
1711 if (mrb_nil_p(path)) {
1713 return mrb_class_find_path(mrb, c);
1715 else if (mrb_symbol_p(path)) {
1716 /* toplevel class/module */
1717 return mrb_sym_str(mrb, mrb_symbol(path));
1719 return mrb_str_dup(mrb, path);
1722 MRB_API struct RClass*
1723 mrb_class_real(struct RClass* cl)
1725 if (cl == 0) return NULL;
1726 while ((cl->tt == MRB_TT_SCLASS) || (cl->tt == MRB_TT_ICLASS)) {
1728 if (cl == 0) return NULL;
1734 mrb_class_name(mrb_state *mrb, struct RClass* c)
1738 if (c == NULL) return NULL;
1739 name = class_name_str(mrb, c);
1740 return RSTRING_PTR(name);
1744 mrb_obj_classname(mrb_state *mrb, mrb_value obj)
1746 return mrb_class_name(mrb, mrb_obj_class(mrb, obj));
1750 * Ensures a class can be derived from super.
1752 * \param super a reference to an object.
1753 * \exception TypeError if \a super is not a Class or \a super is a singleton class.
1756 mrb_check_inheritable(mrb_state *mrb, struct RClass *super)
1758 if (super->tt != MRB_TT_CLASS) {
1759 mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%C given)", super);
1761 if (super->tt == MRB_TT_SCLASS) {
1762 mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of singleton class");
1764 if (super == mrb->class_class) {
1765 mrb_raise(mrb, E_TYPE_ERROR, "can't make subclass of Class");
1770 * Creates a new class.
1771 * \param super a class from which the new class derives.
1772 * \exception TypeError \a super is not inheritable.
1773 * \exception TypeError \a super is the Class class.
1775 MRB_API struct RClass*
1776 mrb_class_new(mrb_state *mrb, struct RClass *super)
1781 mrb_check_inheritable(mrb, super);
1783 c = boot_defclass(mrb, super);
1785 MRB_SET_INSTANCE_TT(c, MRB_INSTANCE_TT(super));
1787 make_metaclass(mrb, c);
1793 * Creates a new module.
1795 MRB_API struct RClass*
1796 mrb_module_new(mrb_state *mrb)
1798 struct RClass *m = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_MODULE, mrb->module_class);
1799 boot_initmod(mrb, m);
1805 * obj.class => class
1807 * Returns the class of <i>obj</i>, now preferred over
1808 * <code>Object#type</code>, as an object's type in Ruby is only
1809 * loosely tied to that object's class. This method must always be
1810 * called with an explicit receiver, as <code>class</code> is also a
1811 * reserved word in Ruby.
1813 * 1.class #=> Fixnum
1814 * self.class #=> Object
1817 MRB_API struct RClass*
1818 mrb_obj_class(mrb_state *mrb, mrb_value obj)
1820 return mrb_class_real(mrb_class(mrb, obj));
1824 mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b)
1826 mrb_method_t m = mrb_method_search(mrb, c, b);
1828 if (!MRB_METHOD_CFUNC_P(m)) {
1829 struct RProc *p = MRB_METHOD_PROC(m);
1831 if (MRB_PROC_ENV_P(p)) {
1832 MRB_PROC_ENV(p)->mid = b;
1835 struct RClass *tc = MRB_PROC_TARGET_CLASS(p);
1836 struct REnv *e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL);
1841 mrb_field_write_barrier(mrb, (struct RBasic*)e, (struct RBasic*)tc);
1844 p->flags |= MRB_PROC_ENVSET;
1847 mrb_define_method_raw(mrb, c, a, m);
1851 * Defines an alias of a method.
1852 * \param mrb the mruby state
1853 * \param klass the class which the original method belongs to
1854 * \param name1 a new name for the method
1855 * \param name2 the original name of the method
1858 mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2)
1860 mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2));
1865 * mod.to_s -> string
1867 * Return a string representing this module or class. For basic
1868 * classes and modules, this is the name. For singletons, we
1869 * show information on the thing we're attached to as well.
1873 mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
1876 if (mrb_sclass_p(klass)) {
1877 mrb_value v = mrb_iv_get(mrb, klass, mrb_intern_lit(mrb, "__attached__"));
1878 mrb_value str = mrb_str_new_lit(mrb, "#<Class:");
1880 if (class_ptr_p(v)) {
1881 mrb_str_cat_str(mrb, str, mrb_inspect(mrb, v));
1884 mrb_str_cat_str(mrb, str, mrb_any_to_s(mrb, v));
1886 return mrb_str_cat_lit(mrb, str, ">");
1889 return class_name_str(mrb, mrb_class_ptr(klass));
1894 mrb_mod_alias(mrb_state *mrb, mrb_value mod)
1896 struct RClass *c = mrb_class_ptr(mod);
1897 mrb_sym new_name, old_name;
1899 mrb_get_args(mrb, "nn", &new_name, &old_name);
1900 mrb_alias_method(mrb, c, new_name, old_name);
1905 undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
1909 MRB_METHOD_FROM_PROC(m, NULL);
1910 mrb_define_method_raw(mrb, c, a, m);
1914 mrb_undef_method_id(mrb_state *mrb, struct RClass *c, mrb_sym a)
1916 if (!mrb_obj_respond_to(mrb, c, a)) {
1917 mrb_name_error(mrb, a, "undefined method '%n' for class '%C'", a, c);
1919 undef_method(mrb, c, a);
1923 mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
1925 undef_method(mrb, c, mrb_intern_cstr(mrb, name));
1929 mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name)
1931 mrb_undef_method(mrb, mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
1935 mrb_mod_undef(mrb_state *mrb, mrb_value mod)
1937 struct RClass *c = mrb_class_ptr(mod);
1941 mrb_get_args(mrb, "*", &argv, &argc);
1943 mrb_undef_method_id(mrb, c, to_sym(mrb, *argv));
1946 return mrb_nil_value();
1950 check_const_name_sym(mrb_state *mrb, mrb_sym id)
1953 const char *name = mrb_sym_name_len(mrb, id, &len);
1954 if (!mrb_const_name_p(mrb, name, len)) {
1955 mrb_name_error(mrb, id, "wrong constant name %n", id);
1960 mrb_mod_const_defined(mrb_state *mrb, mrb_value mod)
1963 mrb_bool inherit = TRUE;
1965 mrb_get_args(mrb, "n|b", &id, &inherit);
1966 check_const_name_sym(mrb, id);
1968 return mrb_bool_value(mrb_const_defined(mrb, mod, id));
1970 return mrb_bool_value(mrb_const_defined_at(mrb, mod, id));
1974 mrb_const_get_sym(mrb_state *mrb, mrb_value mod, mrb_sym id)
1976 check_const_name_sym(mrb, id);
1977 return mrb_const_get(mrb, mod, id);
1981 mrb_mod_const_get(mrb_state *mrb, mrb_value mod)
1983 mrb_value path = mrb_get_arg1(mrb);
1986 mrb_int off, end, len;
1988 if (mrb_symbol_p(path)) {
1989 /* const get with symbol */
1990 id = mrb_symbol(path);
1991 return mrb_const_get_sym(mrb, mod, id);
1994 /* const get with class path string */
1995 path = mrb_ensure_string_type(mrb, path);
1996 ptr = RSTRING_PTR(path);
1997 len = RSTRING_LEN(path);
2001 end = mrb_str_index_lit(mrb, path, "::", off);
2002 end = (end == -1) ? len : end;
2003 id = mrb_intern(mrb, ptr+off, end-off);
2004 mod = mrb_const_get_sym(mrb, mod, id);
2009 if (off == len) { /* trailing "::" */
2010 mrb_name_error(mrb, id, "wrong constant name '%v'", path);
2019 mrb_mod_const_set(mrb_state *mrb, mrb_value mod)
2024 mrb_get_args(mrb, "no", &id, &value);
2025 check_const_name_sym(mrb, id);
2026 mrb_const_set(mrb, mod, id, value);
2031 mrb_mod_remove_const(mrb_state *mrb, mrb_value mod)
2036 mrb_get_args(mrb, "n", &id);
2037 check_const_name_sym(mrb, id);
2038 val = mrb_iv_remove(mrb, mod, id);
2039 if (mrb_undef_p(val)) {
2040 mrb_name_error(mrb, id, "constant %n not defined", id);
2046 mrb_mod_const_missing(mrb_state *mrb, mrb_value mod)
2050 mrb_get_args(mrb, "n", &sym);
2052 if (mrb_class_real(mrb_class_ptr(mod)) != mrb->object_class) {
2053 mrb_name_error(mrb, sym, "uninitialized constant %v::%n", mod, sym);
2056 mrb_name_error(mrb, sym, "uninitialized constant %n", sym);
2059 return mrb_nil_value();
2065 * mod.method_defined?(symbol) -> true or false
2067 * Returns +true+ if the named method is defined by
2068 * _mod_ (or its included modules and, if _mod_ is a class,
2069 * its ancestors). Public and protected methods are matched.
2082 * A.method_defined? :method1 #=> true
2083 * C.method_defined? "method1" #=> true
2084 * C.method_defined? "method2" #=> true
2085 * C.method_defined? "method3" #=> true
2086 * C.method_defined? "method4" #=> false
2090 mrb_mod_method_defined(mrb_state *mrb, mrb_value mod)
2094 mrb_get_args(mrb, "n", &id);
2095 return mrb_bool_value(mrb_obj_respond_to(mrb, mrb_class_ptr(mod), id));
2099 mod_define_method(mrb_state *mrb, mrb_value self)
2101 struct RClass *c = mrb_class_ptr(self);
2105 mrb_value proc = mrb_undef_value();
2108 mrb_get_args(mrb, "n|o&", &mid, &proc, &blk);
2109 switch (mrb_type(proc)) {
2117 mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %T (expected Proc)", proc);
2120 if (mrb_nil_p(blk)) {
2121 mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
2123 p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class);
2124 mrb_proc_copy(p, mrb_proc_ptr(blk));
2125 p->flags |= MRB_PROC_STRICT;
2126 MRB_METHOD_FROM_PROC(m, p);
2127 mrb_define_method_raw(mrb, c, mid, m);
2128 return mrb_symbol_value(mid);
2132 top_define_method(mrb_state *mrb, mrb_value self)
2134 return mod_define_method(mrb, mrb_obj_value(mrb->object_class));
2138 mrb_mod_eqq(mrb_state *mrb, mrb_value mod)
2140 mrb_value obj = mrb_get_arg1(mrb);
2143 eqq = mrb_obj_is_kind_of(mrb, obj, mrb_class_ptr(mod));
2145 return mrb_bool_value(eqq);
2149 mrb_mod_dup(mrb_state *mrb, mrb_value self)
2151 mrb_value mod = mrb_obj_clone(mrb, self);
2152 MRB_UNSET_FROZEN_FLAG(mrb_obj_ptr(mod));
2157 mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
2163 struct RClass *rclass;
2166 mrb_check_type(mrb, mod, MRB_TT_MODULE);
2168 mrb_get_args(mrb, "*", &argv, &argc);
2170 /* set MODFUNC SCOPE if implemented */
2174 /* set PRIVATE method visibility if implemented */
2175 /* mrb_mod_dummy_visibility(mrb, mod); */
2177 for (i=0; i<argc; i++) {
2178 mrb_check_type(mrb, argv[i], MRB_TT_SYMBOL);
2180 mid = mrb_symbol(argv[i]);
2181 rclass = mrb_class_ptr(mod);
2182 m = mrb_method_search(mrb, rclass, mid);
2184 prepare_singleton_class(mrb, (struct RBasic*)rclass);
2185 ai = mrb_gc_arena_save(mrb);
2186 mrb_define_method_raw(mrb, rclass->c, mid, m);
2187 mrb_gc_arena_restore(mrb, ai);
2193 /* implementation of __id__ */
2194 mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self);
2195 /* implementation of instance_eval */
2196 mrb_value mrb_obj_instance_eval(mrb_state*, mrb_value);
2199 inspect_main(mrb_state *mrb, mrb_value mod)
2201 return mrb_str_new_lit(mrb, "main");
2204 static const mrb_code new_iseq[] = {
2205 OP_ENTER, 0x0, 0x10, 0x1, /* OP_ENTER 0:0:1:0:0:0:1 */
2206 OP_LOADSELF, 0x3, /* OP_LOADSELF R3 */
2207 OP_SEND, 0x3, 0x0, 0x0, /* OP_SEND R3 :allocate 0 */
2208 OP_MOVE, 0x0, 0x3, /* OP_MOVE R0 R3 */
2209 OP_MOVE, 0x4, 0x1, /* OP_MOVE R4 R1 */
2210 OP_MOVE, 0x5, 0x2, /* OP_MOVE R5 R2 */
2211 OP_SENDVB, 0x3, 0x1, /* OP_SENDVB R4 :initialize */
2212 OP_RETURN, 0x0 /* OP_RETURN R0 */
2216 init_class_new(mrb_state *mrb, struct RClass *cls)
2220 mrb_irep *new_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
2221 static const mrb_irep mrb_irep_zero = { 0 };
2223 *new_irep = mrb_irep_zero;
2224 new_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2);
2225 new_irep->syms[0] = mrb_intern_lit(mrb, "allocate");
2226 new_irep->syms[1] = mrb_intern_lit(mrb, "initialize");
2228 new_irep->flags = MRB_ISEQ_NO_FREE;
2229 new_irep->iseq = new_iseq;
2230 new_irep->ilen = sizeof(new_iseq);
2231 new_irep->nregs = 6;
2232 new_irep->nlocals = 3;
2233 p = mrb_proc_new(mrb, new_irep);
2234 MRB_METHOD_FROM_PROC(m, p);
2235 mrb_define_method_raw(mrb, cls, mrb_intern_lit(mrb, "new"), m);
2239 mrb_init_class(mrb_state *mrb)
2241 struct RClass *bob; /* BasicObject */
2242 struct RClass *obj; /* Object */
2243 struct RClass *mod; /* Module */
2244 struct RClass *cls; /* Class */
2246 /* boot class hierarchy */
2247 bob = boot_defclass(mrb, 0);
2248 obj = boot_defclass(mrb, bob); mrb->object_class = obj;
2249 mod = boot_defclass(mrb, obj); mrb->module_class = mod;/* obj -> mod */
2250 cls = boot_defclass(mrb, mod); mrb->class_class = cls; /* obj -> cls */
2251 /* fix-up loose ends */
2252 bob->c = obj->c = mod->c = cls->c = cls;
2253 make_metaclass(mrb, bob);
2254 make_metaclass(mrb, obj);
2255 make_metaclass(mrb, mod);
2256 make_metaclass(mrb, cls);
2258 /* name basic classes */
2259 mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob));
2260 mrb_define_const(mrb, obj, "Object", mrb_obj_value(obj));
2261 mrb_define_const(mrb, obj, "Module", mrb_obj_value(mod));
2262 mrb_define_const(mrb, obj, "Class", mrb_obj_value(cls));
2264 /* name each classes */
2265 mrb_class_name_class(mrb, NULL, bob, mrb_intern_lit(mrb, "BasicObject"));
2266 mrb_class_name_class(mrb, NULL, obj, mrb_intern_lit(mrb, "Object")); /* 15.2.1 */
2267 mrb_class_name_class(mrb, NULL, mod, mrb_intern_lit(mrb, "Module")); /* 15.2.2 */
2268 mrb_class_name_class(mrb, NULL, cls, mrb_intern_lit(mrb, "Class")); /* 15.2.3 */
2270 mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class); /* 15.2.17 */
2271 MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC);
2273 MRB_SET_INSTANCE_TT(cls, MRB_TT_CLASS);
2274 mrb_define_method(mrb, bob, "initialize", mrb_bob_init, MRB_ARGS_NONE());
2275 mrb_define_method(mrb, bob, "!", mrb_bob_not, MRB_ARGS_NONE());
2276 mrb_define_method(mrb, bob, "==", mrb_obj_equal_m, MRB_ARGS_REQ(1)); /* 15.3.1.3.1 */
2277 mrb_define_method(mrb, bob, "__id__", mrb_obj_id_m, MRB_ARGS_NONE()); /* 15.3.1.3.4 */
2278 mrb_define_method(mrb, bob, "__send__", mrb_f_send, MRB_ARGS_REQ(1)|MRB_ARGS_REST()|MRB_ARGS_BLOCK()); /* 15.3.1.3.5 */
2279 mrb_define_method(mrb, bob, "equal?", mrb_obj_equal_m, MRB_ARGS_REQ(1)); /* 15.3.1.3.11 */
2280 mrb_define_method(mrb, bob, "instance_eval", mrb_obj_instance_eval, MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK()); /* 15.3.1.3.18 */
2282 mrb_define_class_method(mrb, cls, "new", mrb_class_new_class, MRB_ARGS_OPT(1)|MRB_ARGS_BLOCK());
2283 mrb_define_method(mrb, cls, "allocate", mrb_instance_alloc, MRB_ARGS_NONE());
2284 mrb_define_method(mrb, cls, "superclass", mrb_class_superclass, MRB_ARGS_NONE()); /* 15.2.3.3.4 */
2285 mrb_define_method(mrb, cls, "initialize", mrb_class_initialize, MRB_ARGS_OPT(1)); /* 15.2.3.3.1 */
2286 mrb_define_method(mrb, cls, "inherited", mrb_bob_init, MRB_ARGS_REQ(1));
2288 init_class_new(mrb, cls);
2290 MRB_SET_INSTANCE_TT(mod, MRB_TT_MODULE);
2291 mrb_define_method(mrb, mod, "extend_object", mrb_mod_extend_object, MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */
2292 mrb_define_method(mrb, mod, "extended", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */
2293 mrb_define_method(mrb, mod, "prepended", mrb_bob_init, MRB_ARGS_REQ(1));
2294 mrb_define_method(mrb, mod, "prepend_features", mrb_mod_prepend_features, MRB_ARGS_REQ(1));
2295 mrb_define_method(mrb, mod, "include?", mrb_mod_include_p, MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */
2296 mrb_define_method(mrb, mod, "append_features", mrb_mod_append_features, MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */
2297 mrb_define_method(mrb, mod, "class_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.15 */
2298 mrb_define_method(mrb, mod, "included", mrb_bob_init, MRB_ARGS_REQ(1)); /* 15.2.2.4.29 */
2299 mrb_define_method(mrb, mod, "initialize", mrb_mod_initialize, MRB_ARGS_NONE()); /* 15.2.2.4.31 */
2300 mrb_define_method(mrb, mod, "module_eval", mrb_mod_module_eval, MRB_ARGS_ANY()); /* 15.2.2.4.35 */
2301 mrb_define_method(mrb, mod, "module_function", mrb_mod_module_function, MRB_ARGS_ANY());
2302 mrb_define_method(mrb, mod, "private", mrb_mod_dummy_visibility, MRB_ARGS_ANY()); /* 15.2.2.4.36 */
2303 mrb_define_method(mrb, mod, "protected", mrb_mod_dummy_visibility, MRB_ARGS_ANY()); /* 15.2.2.4.37 */
2304 mrb_define_method(mrb, mod, "public", mrb_mod_dummy_visibility, MRB_ARGS_ANY()); /* 15.2.2.4.38 */
2305 mrb_define_method(mrb, mod, "attr_reader", mrb_mod_attr_reader, MRB_ARGS_ANY()); /* 15.2.2.4.13 */
2306 mrb_define_method(mrb, mod, "attr_writer", mrb_mod_attr_writer, MRB_ARGS_ANY()); /* 15.2.2.4.14 */
2307 mrb_define_method(mrb, mod, "to_s", mrb_mod_to_s, MRB_ARGS_NONE());
2308 mrb_define_method(mrb, mod, "inspect", mrb_mod_to_s, MRB_ARGS_NONE());
2309 mrb_define_method(mrb, mod, "alias_method", mrb_mod_alias, MRB_ARGS_ANY()); /* 15.2.2.4.8 */
2310 mrb_define_method(mrb, mod, "ancestors", mrb_mod_ancestors, MRB_ARGS_NONE()); /* 15.2.2.4.9 */
2311 mrb_define_method(mrb, mod, "undef_method", mrb_mod_undef, MRB_ARGS_ANY()); /* 15.2.2.4.41 */
2312 mrb_define_method(mrb, mod, "const_defined?", mrb_mod_const_defined, MRB_ARGS_ARG(1,1)); /* 15.2.2.4.20 */
2313 mrb_define_method(mrb, mod, "const_get", mrb_mod_const_get, MRB_ARGS_REQ(1)); /* 15.2.2.4.21 */
2314 mrb_define_method(mrb, mod, "const_set", mrb_mod_const_set, MRB_ARGS_REQ(2)); /* 15.2.2.4.23 */
2315 mrb_define_method(mrb, mod, "remove_const", mrb_mod_remove_const, MRB_ARGS_REQ(1)); /* 15.2.2.4.40 */
2316 mrb_define_method(mrb, mod, "const_missing", mrb_mod_const_missing, MRB_ARGS_REQ(1));
2317 mrb_define_method(mrb, mod, "method_defined?", mrb_mod_method_defined, MRB_ARGS_REQ(1)); /* 15.2.2.4.34 */
2318 mrb_define_method(mrb, mod, "define_method", mod_define_method, MRB_ARGS_ARG(1,1));
2319 mrb_define_method(mrb, mod, "===", mrb_mod_eqq, MRB_ARGS_REQ(1)); /* 15.2.2.4.7 */
2320 mrb_define_method(mrb, mod, "dup", mrb_mod_dup, MRB_ARGS_NONE());
2322 mrb_undef_method(mrb, cls, "append_features");
2323 mrb_undef_method(mrb, cls, "prepend_features");
2324 mrb_undef_method(mrb, cls, "extend_object");
2325 mrb_undef_method(mrb, cls, "module_function");
2327 mrb->top_self = (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mrb->object_class);
2328 mrb_define_singleton_method(mrb, mrb->top_self, "inspect", inspect_main, MRB_ARGS_NONE());
2329 mrb_define_singleton_method(mrb, mrb->top_self, "to_s", inspect_main, MRB_ARGS_NONE());
2330 mrb_define_singleton_method(mrb, mrb->top_self, "define_method", top_define_method, MRB_ARGS_ARG(1,1));