Ignore:
Timestamp:
Jul 9, 2020, 8:51:43 AM (4 years ago)
Author:
coas-nagasima
Message:

mrubyを2.1.1に更新

Location:
EcnlProtoTool/trunk/mruby-2.1.1
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-2.1.1/src/kernel.c

    r331 r439  
    1515#include <mruby/istruct.h>
    1616
    17 typedef enum {
    18   NOEX_PUBLIC    = 0x00,
    19   NOEX_NOSUPER   = 0x01,
    20   NOEX_PRIVATE   = 0x02,
    21   NOEX_PROTECTED = 0x04,
    22   NOEX_MASK      = 0x06,
    23   NOEX_BASIC     = 0x08,
    24   NOEX_UNDEF     = NOEX_NOSUPER,
    25   NOEX_MODFUNC   = 0x12,
    26   NOEX_SUPER     = 0x20,
    27   NOEX_VCALL     = 0x40,
    28   NOEX_RESPONDS  = 0x80
    29 } mrb_method_flag_t;
    30 
    3117MRB_API mrb_bool
    3218mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)
    3319{
    34   struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mid);
    35   if (MRB_PROC_CFUNC_P(me) && (me->body.func == func))
     20  struct RClass *c = mrb_class(mrb, obj);
     21  mrb_method_t m = mrb_method_search_vm(mrb, &c, mid);
     22  struct RProc *p;
     23
     24  if (MRB_METHOD_UNDEF_P(m)) return FALSE;
     25  if (MRB_METHOD_FUNC_P(m))
     26    return MRB_METHOD_FUNC(m) == func;
     27  p = MRB_METHOD_PROC(m);
     28  if (MRB_PROC_CFUNC_P(p) && (MRB_PROC_CFUNC(p) == func))
    3629    return TRUE;
    3730  return FALSE;
    … …  
    6154mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
    6255{
    63   if ((mrb_type(obj) == MRB_TT_OBJECT) && mrb_obj_basic_to_s_p(mrb, obj)) {
     56  if (mrb_object_p(obj) && mrb_obj_basic_to_s_p(mrb, obj)) {
    6457    return mrb_obj_iv_inspect(mrb, mrb_obj_ptr(obj));
    6558  }
    … …  
    135128mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
    136129{
    137   mrb_callinfo *ci = mrb->c->ci;
     130  mrb_callinfo *ci = &mrb->c->ci[-1];
     131  mrb_callinfo *cibase = mrb->c->cibase;
    138132  mrb_value *bp;
    139 
    140   bp = ci->stackent + 1;
    141   ci--;
    142   if (ci <= mrb->c->cibase) {
     133  struct RProc *p;
     134
     135  if (ci <= cibase) {
     136    /* toplevel does not have block */
    143137    return mrb_false_value();
    144138  }
    145   /* block_given? called within block; check upper scope */
    146   if (ci->proc->env) {
    147     struct REnv *e = ci->proc->env;
    148 
    149     while (e->c) {
    150       e = (struct REnv*)e->c;
    151     }
     139  p = ci->proc;
     140  /* search method/class/module proc */
     141  while (p) {
     142    if (MRB_PROC_SCOPE_P(p)) break;
     143    p = p->upper;
     144  }
     145  if (p == NULL) return mrb_false_value();
     146  /* search ci corresponding to proc */
     147  while (cibase < ci) {
     148    if (ci->proc == p) break;
     149    ci--;
     150  }
     151  if (ci == cibase) {
     152    return mrb_false_value();
     153  }
     154  else if (ci->env) {
     155    struct REnv *e = ci->env;
     156    int bidx;
     157
    152158    /* top-level does not have block slot (always false) */
    153159    if (e->stack == mrb->c->stbase)
    154160      return mrb_false_value();
    155     if (e->stack && e->cioff < 0) {
    156       /* use saved block arg position */
    157       bp = &e->stack[-e->cioff];
    158       ci = 0;                 /* no callinfo available */
     161    /* use saved block arg position */
     162    bidx = MRB_ENV_BIDX(e);
     163    /* bidx may be useless (e.g. define_method) */
     164    if (bidx >= MRB_ENV_STACK_LEN(e))
     165      return mrb_false_value();
     166    bp = &e->stack[bidx];
     167  }
     168  else {
     169    bp = ci[1].stackent+1;
     170    if (ci->argc >= 0) {
     171      bp += ci->argc;
    159172    }
    160173    else {
    161       ci = e->cxt.c->cibase + e->cioff;
    162       bp = ci[1].stackent + 1;
    163     }
    164   }
    165   if (ci && ci->argc > 0) {
    166     bp += ci->argc;
     174      bp++;
     175    }
    167176  }
    168177  if (mrb_nil_p(*bp))
    … …  
    231240  /* if the origin is not the same as the class, then the origin and
    232241     the current class need to be copied */
    233   if (sc->flags & MRB_FLAG_IS_PREPENDED) {
     242  if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) {
    234243    struct RClass *c0 = sc->super;
    235244    struct RClass *c1 = dc;
    236245
    237246    /* copy prepended iclasses */
    238     while (!(c0->flags & MRB_FLAG_IS_ORIGIN)) {
     247    while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) {
    239248      c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
    240249      c1 = c1->super;
    … …  
    242251    }
    243252    c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
    244     c1->super->flags |= MRB_FLAG_IS_ORIGIN;
     253    c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN;
    245254  }
    246255  if (sc->mt) {
    … …  
    258267{
    259268  switch (mrb_type(obj)) {
     269    case MRB_TT_ICLASS:
     270      copy_class(mrb, dest, obj);
     271      return;
    260272    case MRB_TT_CLASS:
    261273    case MRB_TT_MODULE:
    262274      copy_class(mrb, dest, obj);
    263       /* fall through */
     275      mrb_iv_copy(mrb, dest, obj);
     276      mrb_iv_remove(mrb, dest, mrb_intern_lit(mrb, "__classname__"));
     277      break;
    264278    case MRB_TT_OBJECT:
    265279    case MRB_TT_SCLASS:
    … …  
    312326
    313327  if (mrb_immediate_p(self)) {
    314     mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %S", self);
    315   }
    316   if (mrb_type(self) == MRB_TT_SCLASS) {
     328    mrb_raisef(mrb, E_TYPE_ERROR, "can't clone %v", self);
     329  }
     330  if (mrb_sclass_p(self)) {
    317331    mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class");
    318332  }
    319333  p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
    320334  p->c = mrb_singleton_class_clone(mrb, self);
     335  mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)p->c);
    321336  clone = mrb_obj_value(p);
    322337  init_copy(mrb, clone, self);
     338  p->flags |= mrb_obj_ptr(self)->flags & MRB_FL_OBJ_IS_FROZEN;
    323339
    324340  return clone;
    … …  
    351367
    352368  if (mrb_immediate_p(obj)) {
    353     mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %S", obj);
    354   }
    355   if (mrb_type(obj) == MRB_TT_SCLASS) {
     369    mrb_raisef(mrb, E_TYPE_ERROR, "can't dup %v", obj);
     370  }
     371  if (mrb_sclass_p(obj)) {
    356372    mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class");
    357373  }
    … …  
    369385
    370386  if (argc == 0) {
    371     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)");
     387    mrb_argnum_error(mrb, argc, 1, -1);
    372388  }
    373389  for (i = 0; i < argc; i++) {
    … …  
    411427  mrb_value *argv;
    412428  mrb_int argc;
    413   mrb_value args;
    414429
    415430  mrb_get_args(mrb, "*", &argv, &argc);
    416   args = mrb_ary_new_from_values(mrb, argc, argv);
    417   argv = (mrb_value*)RARRAY_PTR(args);
    418431  return mrb_obj_extend(mrb, argc, argv, self);
    419432}
    420433
    421 static mrb_value
     434MRB_API mrb_value
    422435mrb_obj_freeze(mrb_state *mrb, mrb_value self)
    423436{
    424   struct RBasic *b;
    425 
    426   switch (mrb_type(self)) {
    427     case MRB_TT_FALSE:
    428     case MRB_TT_TRUE:
    429     case MRB_TT_FIXNUM:
    430     case MRB_TT_SYMBOL:
    431     case MRB_TT_FLOAT:
    432       return self;
    433     default:
    434       break;
    435   }
    436 
    437   b = mrb_basic_ptr(self);
    438   if (!MRB_FROZEN_P(b)) {
    439     MRB_SET_FROZEN_FLAG(b);
     437  if (!mrb_immediate_p(self)) {
     438    struct RBasic *b = mrb_basic_ptr(self);
     439    if (!mrb_frozen_p(b)) {
     440      MRB_SET_FROZEN_FLAG(b);
     441      if (b->c->tt == MRB_TT_SCLASS) MRB_SET_FROZEN_FLAG(b->c);
     442    }
    440443  }
    441444  return self;
    … …  
    445448mrb_obj_frozen(mrb_state *mrb, mrb_value self)
    446449{
    447   struct RBasic *b;
    448 
    449   switch (mrb_type(self)) {
    450     case MRB_TT_FALSE:
    451     case MRB_TT_TRUE:
    452     case MRB_TT_FIXNUM:
    453     case MRB_TT_SYMBOL:
    454     case MRB_TT_FLOAT:
    455       return mrb_true_value();
    456     default:
    457       break;
    458   }
    459 
    460   b = mrb_basic_ptr(self);
    461   if (!MRB_FROZEN_P(b)) {
    462     return mrb_false_value();
    463   }
    464   return mrb_true_value();
     450  return mrb_bool_value(mrb_immediate_p(self) || mrb_frozen_p(mrb_basic_ptr(self)));
    465451}
    466452
    … …  
    476462 *  <code>Fixnum</code> will be truncated before being used.
    477463 */
    478 MRB_API mrb_value
     464static mrb_value
    479465mrb_obj_hash(mrb_state *mrb, mrb_value self)
    480466{
    … …  
    520506
    521507  return mrb_bool_value(mrb_obj_is_instance_of(mrb, self, mrb_class_ptr(arg)));
    522 }
    523 
    524 /* 15.3.1.3.20 */
    525 /*
    526  *  call-seq:
    527  *     obj.instance_variable_defined?(symbol)    -> true or false
    528  *
    529  *  Returns <code>true</code> if the given instance variable is
    530  *  defined in <i>obj</i>.
    531  *
    532  *     class Fred
    533  *       def initialize(p1, p2)
    534  *         @a, @b = p1, p2
    535  *       end
    536  *     end
    537  *     fred = Fred.new('cat', 99)
    538  *     fred.instance_variable_defined?(:@a)    #=> true
    539  *     fred.instance_variable_defined?("@b")   #=> true
    540  *     fred.instance_variable_defined?("@c")   #=> false
    541  */
    542 static mrb_value
    543 mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self)
    544 {
    545   mrb_sym sym;
    546 
    547   mrb_get_args(mrb, "n", &sym);
    548   mrb_iv_check(mrb, sym);
    549   return mrb_bool_value(mrb_iv_defined(mrb, self, sym));
    550 }
    551 
    552 /* 15.3.1.3.21 */
    553 /*
    554  *  call-seq:
    555  *     obj.instance_variable_get(symbol)    -> obj
    556  *
    557  *  Returns the value of the given instance variable, or nil if the
    558  *  instance variable is not set. The <code>@</code> part of the
    559  *  variable name should be included for regular instance
    560  *  variables. Throws a <code>NameError</code> exception if the
    561  *  supplied symbol is not valid as an instance variable name.
    562  *
    563  *     class Fred
    564  *       def initialize(p1, p2)
    565  *         @a, @b = p1, p2
    566  *       end
    567  *     end
    568  *     fred = Fred.new('cat', 99)
    569  *     fred.instance_variable_get(:@a)    #=> "cat"
    570  *     fred.instance_variable_get("@b")   #=> 99
    571  */
    572 static mrb_value
    573 mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
    574 {
    575   mrb_sym iv_name;
    576 
    577   mrb_get_args(mrb, "n", &iv_name);
    578   mrb_iv_check(mrb, iv_name);
    579   return mrb_iv_get(mrb, self, iv_name);
    580 }
    581 
    582 /* 15.3.1.3.22 */
    583 /*
    584  *  call-seq:
    585  *     obj.instance_variable_set(symbol, obj)    -> obj
    586  *
    587  *  Sets the instance variable names by <i>symbol</i> to
    588  *  <i>object</i>, thereby frustrating the efforts of the class's
    589  *  author to attempt to provide proper encapsulation. The variable
    590  *  did not have to exist prior to this call.
    591  *
    592  *     class Fred
    593  *       def initialize(p1, p2)
    594  *         @a, @b = p1, p2
    595  *       end
    596  *     end
    597  *     fred = Fred.new('cat', 99)
    598  *     fred.instance_variable_set(:@a, 'dog')   #=> "dog"
    599  *     fred.instance_variable_set(:@c, 'cat')   #=> "cat"
    600  *     fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
    601  */
    602 static mrb_value
    603 mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
    604 {
    605   mrb_sym iv_name;
    606   mrb_value val;
    607 
    608   mrb_get_args(mrb, "no", &iv_name, &val);
    609   mrb_iv_check(mrb, iv_name);
    610   mrb_iv_set(mrb, self, iv_name, val);
    611   return val;
    612508}
    613509
    … …  
    652548KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal)
    653549
    654 static void
    655 method_entry_loop(mrb_state *mrb, struct RClass* klass, khash_t(st)* set)
    656 {
    657   khint_t i;
    658 
    659   khash_t(mt) *h = klass->mt;
    660   if (!h) return;
    661   for (i=0;i<kh_end(h);i++) {
    662     if (kh_exist(h, i) && kh_value(h, i)) {
    663       kh_put(st, mrb, set, kh_key(h, i));
    664     }
    665   }
    666 }
    667 
    668 mrb_value
    669 mrb_class_instance_method_list(mrb_state *mrb, mrb_bool recur, struct RClass* klass, int obj)
    670 {
    671   khint_t i;
    672   mrb_value ary;
    673   mrb_bool prepended = FALSE;
    674   struct RClass* oldklass;
    675   khash_t(st)* set = kh_init(st, mrb);
    676 
    677   if (!recur && (klass->flags & MRB_FLAG_IS_PREPENDED)) {
    678     MRB_CLASS_ORIGIN(klass);
    679     prepended = TRUE;
    680   }
    681 
    682   oldklass = 0;
    683   while (klass && (klass != oldklass)) {
    684     method_entry_loop(mrb, klass, set);
    685     if ((klass->tt == MRB_TT_ICLASS && !prepended) ||
    686         (klass->tt == MRB_TT_SCLASS)) {
    687     }
    688     else {
    689       if (!recur) break;
    690     }
    691     oldklass = klass;
    692     klass = klass->super;
    693   }
    694 
    695   ary = mrb_ary_new(mrb);
    696   for (i=0;i<kh_end(set);i++) {
    697     if (kh_exist(set, i)) {
    698       mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(set, i)));
    699     }
    700   }
    701   kh_destroy(st, mrb, set);
    702 
    703   return ary;
    704 }
    705 
    706 static mrb_value
    707 mrb_obj_singleton_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj)
    708 {
    709   khint_t i;
    710   mrb_value ary;
    711   struct RClass* klass;
    712   khash_t(st)* set = kh_init(st, mrb);
    713 
    714   klass = mrb_class(mrb, obj);
    715 
    716   if (klass && (klass->tt == MRB_TT_SCLASS)) {
    717       method_entry_loop(mrb, klass, set);
    718       klass = klass->super;
    719   }
    720   if (recur) {
    721       while (klass && ((klass->tt == MRB_TT_SCLASS) || (klass->tt == MRB_TT_ICLASS))) {
    722         method_entry_loop(mrb, klass, set);
    723         klass = klass->super;
    724       }
    725   }
    726 
    727   ary = mrb_ary_new(mrb);
    728   for (i=0;i<kh_end(set);i++) {
    729     if (kh_exist(set, i)) {
    730       mrb_ary_push(mrb, ary, mrb_symbol_value(kh_key(set, i)));
    731     }
    732   }
    733   kh_destroy(st, mrb, set);
    734 
    735   return ary;
    736 }
    737 
    738 static mrb_value
    739 mrb_obj_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj, mrb_method_flag_t flag)
    740 {
    741   return mrb_class_instance_method_list(mrb, recur, mrb_class(mrb, obj), 0);
    742 }
    743 /* 15.3.1.3.31 */
    744 /*
    745  *  call-seq:
    746  *     obj.methods    -> array
    747  *
    748  *  Returns a list of the names of methods publicly accessible in
    749  *  <i>obj</i>. This will include all the methods accessible in
    750  *  <i>obj</i>'s ancestors.
    751  *
    752  *     class Klass
    753  *       def kMethod()
    754  *       end
    755  *     end
    756  *     k = Klass.new
    757  *     k.methods[0..9]    #=> [:kMethod, :respond_to?, :nil?, :is_a?,
    758  *                        #    :class, :instance_variable_set,
    759  *                        #    :methods, :extend, :__send__, :instance_eval]
    760  *     k.methods.length   #=> 42
    761  */
    762 static mrb_value
    763 mrb_obj_methods_m(mrb_state *mrb, mrb_value self)
    764 {
    765   mrb_bool recur = TRUE;
    766   mrb_get_args(mrb, "|b", &recur);
    767   return mrb_obj_methods(mrb, recur, self, (mrb_method_flag_t)0); /* everything but private */
    768 }
    769 
    770550/* 15.3.1.3.32 */
    771551/*
    … …  
    780560{
    781561  return mrb_false_value();
    782 }
    783 
    784 /* 15.3.1.3.36 */
    785 /*
    786  *  call-seq:
    787  *     obj.private_methods(all=true)   -> array
    788  *
    789  *  Returns the list of private methods accessible to <i>obj</i>. If
    790  *  the <i>all</i> parameter is set to <code>false</code>, only those methods
    791  *  in the receiver will be listed.
    792  */
    793 static mrb_value
    794 mrb_obj_private_methods(mrb_state *mrb, mrb_value self)
    795 {
    796   mrb_bool recur = TRUE;
    797   mrb_get_args(mrb, "|b", &recur);
    798   return mrb_obj_methods(mrb, recur, self, NOEX_PRIVATE); /* private attribute not define */
    799 }
    800 
    801 /* 15.3.1.3.37 */
    802 /*
    803  *  call-seq:
    804  *     obj.protected_methods(all=true)   -> array
    805  *
    806  *  Returns the list of protected methods accessible to <i>obj</i>. If
    807  *  the <i>all</i> parameter is set to <code>false</code>, only those methods
    808  *  in the receiver will be listed.
    809  */
    810 static mrb_value
    811 mrb_obj_protected_methods(mrb_state *mrb, mrb_value self)
    812 {
    813   mrb_bool recur = TRUE;
    814   mrb_get_args(mrb, "|b", &recur);
    815   return mrb_obj_methods(mrb, recur, self, NOEX_PROTECTED); /* protected attribute not define */
    816 }
    817 
    818 /* 15.3.1.3.38 */
    819 /*
    820  *  call-seq:
    821  *     obj.public_methods(all=true)   -> array
    822  *
    823  *  Returns the list of public methods accessible to <i>obj</i>. If
    824  *  the <i>all</i> parameter is set to <code>false</code>, only those methods
    825  *  in the receiver will be listed.
    826  */
    827 static mrb_value
    828 mrb_obj_public_methods(mrb_state *mrb, mrb_value self)
    829 {
    830   mrb_bool recur = TRUE;
    831   mrb_get_args(mrb, "|b", &recur);
    832   return mrb_obj_methods(mrb, recur, self, NOEX_PUBLIC); /* public attribute not define */
    833562}
    834563
    … …  
    858587{
    859588  mrb_value a[2], exc;
    860   int argc;
     589  mrb_int argc;
    861590
    862591
    … …  
    910639
    911640  mrb_get_args(mrb, "n", &sym);
    912   mrb_iv_check(mrb, sym);
     641  mrb_iv_name_sym_check(mrb, sym);
    913642  val = mrb_iv_remove(mrb, self, sym);
    914643  if (mrb_undef_p(val)) {
    915     mrb_name_error(mrb, sym, "instance variable %S not defined", mrb_sym2str(mrb, sym));
     644    mrb_name_error(mrb, sym, "instance variable %n not defined", sym);
    916645  }
    917646  return val;
    … …  
    921650mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args)
    922651{
    923   mrb_sym inspect;
    924   mrb_value repr;
    925 
    926   inspect = mrb_intern_lit(mrb, "inspect");
    927   if (mrb->c->ci > mrb->c->cibase && mrb->c->ci[-1].mid == inspect) {
    928     /* method missing in inspect; avoid recursion */
    929     repr = mrb_any_to_s(mrb, self);
    930   }
    931   else if (mrb_respond_to(mrb, self, inspect) && mrb->c->ci - mrb->c->cibase < 16) {
    932     repr = mrb_funcall_argv(mrb, self, inspect, 0, 0);
    933     if (mrb_string_p(repr) && RSTRING_LEN(repr) > 64) {
    934       repr = mrb_any_to_s(mrb, self);
    935     }
    936   }
    937   else {
    938     repr = mrb_any_to_s(mrb, self);
    939   }
    940 
    941   mrb_no_method_error(mrb, name, args, "undefined method '%S' for %S",
    942                       mrb_sym2str(mrb, name), repr);
     652  mrb_no_method_error(mrb, name, args, "undefined method '%n'", name);
    943653}
    944654
    … …  
    976686 *     r.mm      #=> 2000
    977687 */
    978 #ifdef MRB_DEFAULT_METHOD_MISSING
    979688static mrb_value
    980689mrb_obj_missing(mrb_state *mrb, mrb_value mod)
    … …  
    984693  mrb_int alen;
    985694
    986   mrb_get_args(mrb, "n*", &name, &a, &alen);
     695  mrb_get_args(mrb, "n*!", &name, &a, &alen);
    987696  mrb_method_missing(mrb, name, mod, mrb_ary_new_from_values(mrb, alen, a));
    988697  /* not reached */
    989698  return mrb_nil_value();
    990699}
    991 #endif
    992700
    993701static inline mrb_bool
    … …  
    996704  return mrb_respond_to(mrb, obj, id);
    997705}
     706
    998707/* 15.3.1.3.43 */
    999708/*
    … …  
    1015724obj_respond_to(mrb_state *mrb, mrb_value self)
    1016725{
    1017   mrb_value mid;
    1018726  mrb_sym id, rtm_id;
    1019   mrb_bool priv = FALSE, respond_to_p = TRUE;
    1020 
    1021   mrb_get_args(mrb, "o|b", &mid, &priv);
    1022 
    1023   if (mrb_symbol_p(mid)) {
    1024     id = mrb_symbol(mid);
    1025   }
    1026   else {
    1027     mrb_value tmp;
    1028     if (mrb_string_p(mid)) {
    1029       tmp = mrb_check_intern_str(mrb, mid);
    1030     }
    1031     else {
    1032       tmp = mrb_check_string_type(mrb, mid);
    1033       if (mrb_nil_p(tmp)) {
    1034         tmp = mrb_inspect(mrb, mid);
    1035         mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", tmp);
    1036       }
    1037       tmp = mrb_check_intern_str(mrb, tmp);
    1038     }
    1039     if (mrb_nil_p(tmp)) {
    1040       respond_to_p = FALSE;
    1041     }
    1042     else {
    1043       id = mrb_symbol(tmp);
    1044     }
    1045   }
    1046 
    1047   if (respond_to_p) {
    1048     respond_to_p = basic_obj_respond_to(mrb, self, id, !priv);
    1049   }
    1050 
     727  mrb_bool priv = FALSE, respond_to_p;
     728
     729  mrb_get_args(mrb, "n|b", &id, &priv);
     730  respond_to_p = basic_obj_respond_to(mrb, self, id, !priv);
    1051731  if (!respond_to_p) {
    1052732    rtm_id = mrb_intern_lit(mrb, "respond_to_missing?");
    1053733    if (basic_obj_respond_to(mrb, self, rtm_id, !priv)) {
    1054734      mrb_value args[2], v;
    1055       args[0] = mid;
     735      args[0] = mrb_symbol_value(id);
    1056736      args[1] = mrb_bool_value(priv);
    1057737      v = mrb_funcall_argv(mrb, self, rtm_id, 2, args);
    … …  
    1060740  }
    1061741  return mrb_bool_value(respond_to_p);
    1062 }
    1063 
    1064 /* 15.3.1.3.45 */
    1065 /*
    1066  *  call-seq:
    1067  *     obj.singleton_methods(all=true)    -> array
    1068  *
    1069  *  Returns an array of the names of singleton methods for <i>obj</i>.
    1070  *  If the optional <i>all</i> parameter is true, the list will include
    1071  *  methods in modules included in <i>obj</i>.
    1072  *  Only public and protected singleton methods are returned.
    1073  *
    1074  *     module Other
    1075  *       def three() end
    1076  *     end
    1077  *
    1078  *     class Single
    1079  *       def Single.four() end
    1080  *     end
    1081  *
    1082  *     a = Single.new
    1083  *
    1084  *     def a.one()
    1085  *     end
    1086  *
    1087  *     class << a
    1088  *       include Other
    1089  *       def two()
    1090  *       end
    1091  *     end
    1092  *
    1093  *     Single.singleton_methods    #=> [:four]
    1094  *     a.singleton_methods(false)  #=> [:two, :one]
    1095  *     a.singleton_methods         #=> [:two, :one, :three]
    1096  */
    1097 static mrb_value
    1098 mrb_obj_singleton_methods_m(mrb_state *mrb, mrb_value self)
    1099 {
    1100   mrb_bool recur = TRUE;
    1101   mrb_get_args(mrb, "|b", &recur);
    1102   return mrb_obj_singleton_methods(mrb, recur, self);
    1103 }
    1104 
    1105 static mrb_value
    1106 mod_define_singleton_method(mrb_state *mrb, mrb_value self)
    1107 {
    1108   struct RProc *p;
    1109   mrb_sym mid;
    1110   mrb_value blk = mrb_nil_value();
    1111 
    1112   mrb_get_args(mrb, "n&", &mid, &blk);
    1113   if (mrb_nil_p(blk)) {
    1114     mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
    1115   }
    1116   p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class);
    1117   mrb_proc_copy(p, mrb_proc_ptr(blk));
    1118   p->flags |= MRB_PROC_STRICT;
    1119   mrb_define_method_raw(mrb, mrb_class_ptr(mrb_singleton_class(mrb, self)), mid, p);
    1120   return mrb_symbol_value(mid);
    1121742}
    1122743
    … …  
    1138759}
    1139760
    1140 static mrb_value
    1141 mrb_local_variables(mrb_state *mrb, mrb_value self)
    1142 {
    1143   struct RProc *proc;
    1144   mrb_value vars;
    1145   struct mrb_irep *irep;
    1146   size_t i;
    1147 
    1148   proc = mrb->c->ci[-1].proc;
    1149 
    1150   if (MRB_PROC_CFUNC_P(proc)) {
    1151     return mrb_ary_new(mrb);
    1152   }
    1153 
    1154   irep = proc->body.irep;
    1155   if (!irep->lv) {
    1156     return mrb_ary_new(mrb);
    1157   }
    1158   vars = mrb_hash_new(mrb);
    1159   for (i = 0; i + 1 < irep->nlocals; ++i) {
    1160     if (irep->lv[i].name) {
    1161       mrb_hash_set(mrb, vars, mrb_symbol_value(irep->lv[i].name), mrb_true_value());
    1162     }
    1163   }
    1164   if (proc->env) {
    1165     struct REnv *e = proc->env;
    1166 
    1167     while (e) {
    1168       if (MRB_ENV_STACK_SHARED_P(e) &&
    1169           !MRB_PROC_CFUNC_P(e->cxt.c->cibase[e->cioff].proc)) {
    1170         irep = e->cxt.c->cibase[e->cioff].proc->body.irep;
    1171         if (irep->lv) {
    1172           for (i = 0; i + 1 < irep->nlocals; ++i) {
    1173             if (irep->lv[i].name) {
    1174               mrb_hash_set(mrb, vars, mrb_symbol_value(irep->lv[i].name), mrb_true_value());
    1175             }
    1176           }
    1177         }
    1178       }
    1179       e = (struct REnv*)e->c;
    1180     }
    1181   }
    1182 
    1183   return mrb_hash_keys(mrb, vars);
    1184 }
    1185 
    1186761mrb_value mrb_obj_equal_m(mrb_state *mrb, mrb_value);
     762
    1187763void
    1188764mrb_init_kernel(mrb_state *mrb)
    … …  
    1192768  mrb->kernel_module = krn = mrb_define_module(mrb, "Kernel");                                                    /* 15.3.1 */
    1193769  mrb_define_class_method(mrb, krn, "block_given?",         mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.2.2  */
    1194   mrb_define_class_method(mrb, krn, "global_variables",     mrb_f_global_variables,          MRB_ARGS_NONE());    /* 15.3.1.2.4  */
    1195770  mrb_define_class_method(mrb, krn, "iterator?",            mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.2.5  */
    1196   mrb_define_class_method(mrb, krn, "local_variables",      mrb_local_variables,             MRB_ARGS_NONE());    /* 15.3.1.2.7  */
    1197771;     /* 15.3.1.2.11 */
    1198772  mrb_define_class_method(mrb, krn, "raise",                mrb_f_raise,                     MRB_ARGS_OPT(2));    /* 15.3.1.2.12 */
    1199773
    1200   mrb_define_method(mrb, krn, "singleton_class",            mrb_singleton_class,             MRB_ARGS_NONE());
    1201774
    1202775  mrb_define_method(mrb, krn, "===",                        mrb_equal_m,                     MRB_ARGS_REQ(1));    /* 15.3.1.3.2  */
    … …  
    1206779  mrb_define_method(mrb, krn, "dup",                        mrb_obj_dup,                     MRB_ARGS_NONE());    /* 15.3.1.3.9  */
    1207780  mrb_define_method(mrb, krn, "eql?",                       mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.10 */
    1208   mrb_define_method(mrb, krn, "equal?",                     mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.11 */
    1209781  mrb_define_method(mrb, krn, "extend",                     mrb_obj_extend_m,                MRB_ARGS_ANY());     /* 15.3.1.3.13 */
    1210782  mrb_define_method(mrb, krn, "freeze",                     mrb_obj_freeze,                  MRB_ARGS_NONE());
    1211783  mrb_define_method(mrb, krn, "frozen?",                    mrb_obj_frozen,                  MRB_ARGS_NONE());
    1212   mrb_define_method(mrb, krn, "global_variables",           mrb_f_global_variables,          MRB_ARGS_NONE());    /* 15.3.1.3.14 */
    1213784  mrb_define_method(mrb, krn, "hash",                       mrb_obj_hash,                    MRB_ARGS_NONE());    /* 15.3.1.3.15 */
    1214785  mrb_define_method(mrb, krn, "initialize_copy",            mrb_obj_init_copy,               MRB_ARGS_REQ(1));    /* 15.3.1.3.16 */
    1215786  mrb_define_method(mrb, krn, "inspect",                    mrb_obj_inspect,                 MRB_ARGS_NONE());    /* 15.3.1.3.17 */
    1216787  mrb_define_method(mrb, krn, "instance_of?",               obj_is_instance_of,              MRB_ARGS_REQ(1));    /* 15.3.1.3.19 */
    1217   mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined,            MRB_ARGS_REQ(1));    /* 15.3.1.3.20 */
    1218   mrb_define_method(mrb, krn, "instance_variable_get",      mrb_obj_ivar_get,                MRB_ARGS_REQ(1));    /* 15.3.1.3.21 */
    1219   mrb_define_method(mrb, krn, "instance_variable_set",      mrb_obj_ivar_set,                MRB_ARGS_REQ(2));    /* 15.3.1.3.22 */
    1220   mrb_define_method(mrb, krn, "instance_variables",         mrb_obj_instance_variables,      MRB_ARGS_NONE());    /* 15.3.1.3.23 */
     788
    1221789  mrb_define_method(mrb, krn, "is_a?",                      mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.24 */
    1222790  mrb_define_method(mrb, krn, "iterator?",                  mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.3.25 */
    1223791  mrb_define_method(mrb, krn, "kind_of?",                   mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.26 */
    1224   mrb_define_method(mrb, krn, "local_variables",            mrb_local_variables,             MRB_ARGS_NONE());    /* 15.3.1.3.28 */
    1225 #ifdef MRB_DEFAULT_METHOD_MISSING
    1226792  mrb_define_method(mrb, krn, "method_missing",             mrb_obj_missing,                 MRB_ARGS_ANY());     /* 15.3.1.3.30 */
    1227 #endif
    1228   mrb_define_method(mrb, krn, "methods",                    mrb_obj_methods_m,               MRB_ARGS_OPT(1));    /* 15.3.1.3.31 */
    1229793  mrb_define_method(mrb, krn, "nil?",                       mrb_false,                       MRB_ARGS_NONE());    /* 15.3.1.3.32 */
    1230794  mrb_define_method(mrb, krn, "object_id",                  mrb_obj_id_m,                    MRB_ARGS_NONE());    /* 15.3.1.3.33 */
    1231   mrb_define_method(mrb, krn, "private_methods",            mrb_obj_private_methods,         MRB_ARGS_OPT(1));    /* 15.3.1.3.36 */
    1232   mrb_define_method(mrb, krn, "protected_methods",          mrb_obj_protected_methods,       MRB_ARGS_OPT(1));    /* 15.3.1.3.37 */
    1233   mrb_define_method(mrb, krn, "public_methods",             mrb_obj_public_methods,          MRB_ARGS_OPT(1));    /* 15.3.1.3.38 */
    1234795  mrb_define_method(mrb, krn, "raise",                      mrb_f_raise,                     MRB_ARGS_ANY());     /* 15.3.1.3.40 */
    1235796  mrb_define_method(mrb, krn, "remove_instance_variable",   mrb_obj_remove_instance_variable,MRB_ARGS_REQ(1));    /* 15.3.1.3.41 */
    1236   mrb_define_method(mrb, krn, "respond_to?",                obj_respond_to,                  MRB_ARGS_ANY());     /* 15.3.1.3.43 */
    1237   mrb_define_method(mrb, krn, "send",                       mrb_f_send,                      MRB_ARGS_ANY());     /* 15.3.1.3.44 */
    1238   mrb_define_method(mrb, krn, "singleton_methods",          mrb_obj_singleton_methods_m,     MRB_ARGS_OPT(1));    /* 15.3.1.3.45 */
    1239   mrb_define_method(mrb, krn, "define_singleton_method",    mod_define_singleton_method,     MRB_ARGS_ANY());
     797  mrb_define_method(mrb, krn, "respond_to?",                obj_respond_to,                  MRB_ARGS_ARG(1,1));     /* 15.3.1.3.43 */
    1240798  mrb_define_method(mrb, krn, "to_s",                       mrb_any_to_s,                    MRB_ARGS_NONE());    /* 15.3.1.3.46 */
    1241799  mrb_define_method(mrb, krn, "__case_eqq",                 mrb_obj_ceqq,                    MRB_ARGS_REQ(1));    /* internal */
     800  mrb_define_method(mrb, krn, "__to_int",                   mrb_to_int,                      MRB_ARGS_NONE()); /* internal */
     801  mrb_define_method(mrb, krn, "__to_str",                   mrb_to_str,                      MRB_ARGS_NONE()); /* internal */
    1242802
    1243803  mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
    1244   mrb_alias_method(mrb, mrb->module_class, mrb_intern_lit(mrb, "dup"), mrb_intern_lit(mrb, "clone"));
    1245 }
     804}
Note: See TracChangeset for help on using the changeset viewer.