Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

Location:
EcnlProtoTool/trunk/mruby-1.3.0
Files:
32 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-1.3.0/src/array.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/array.h"
    9 #include "mruby/class.h"
    10 #include "mruby/string.h"
    11 #include "mruby/range.h"
     7#include <mruby.h>
     8#include <mruby/array.h>
     9#include <mruby/class.h>
     10#include <mruby/string.h>
     11#include <mruby/range.h>
    1212#include "value_array.h"
    1313
    … …  
    1717#define ARY_MAX_SIZE ((ARY_C_MAX_SIZE < (size_t)MRB_INT_MAX) ? (mrb_int)ARY_C_MAX_SIZE : MRB_INT_MAX-1)
    1818
    19 static inline mrb_value
    20 ary_elt(mrb_value ary, mrb_int offset)
    21 {
    22   if (offset < 0 || RARRAY_LEN(ary) <= offset) {
    23     return mrb_nil_value();
    24   }
    25   return RARRAY_PTR(ary)[offset];
    26 }
    27 
    2819static struct RArray*
    2920ary_new_capa(mrb_state *mrb, mrb_int capa)
    3021{
    3122  struct RArray *a;
    32   mrb_int blen;
     23  size_t blen;
    3324
    3425  if (capa > ARY_MAX_SIZE) {
    … …  
    3627  }
    3728  blen = capa * sizeof(mrb_value);
    38   if (blen < capa) {
    39     mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    40   }
    4129
    4230  a = (struct RArray*)mrb_obj_alloc(mrb, MRB_TT_ARRAY, mrb->array_class);
    … …  
    121109ary_modify(mrb_state *mrb, struct RArray *a)
    122110{
     111  if (MRB_FROZEN_P(a)) {
     112    mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen array");
     113  }
     114
    123115  if (ARY_SHARED_P(a)) {
    124116    mrb_shared_array *shared = a->aux.shared;
    … …  
    179171
    180172  if (len > ARY_MAX_SIZE) {
     173  size_error:
    181174    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
    182175  }
    … …  
    186179  }
    187180  while (capa < len) {
    188     capa *= 2;
    189   }
    190 
    191   if (capa > ARY_MAX_SIZE) capa = ARY_MAX_SIZE; /* len <= capa <= ARY_MAX_SIZE */
     181    if (capa <= ARY_MAX_SIZE / 2) {
     182      capa *= 2;
     183    }
     184    else {
     185      capa = len;
     186    }
     187  }
     188  if (capa < len || capa > ARY_MAX_SIZE) {
     189    goto size_error;
     190  }
    192191
    193192  if (capa > a->aux.capa) {
    … …  
    244243
    245244static mrb_value
    246 mrb_ary_s_create(mrb_state *mrb, mrb_value self)
    247 {
     245mrb_ary_s_create(mrb_state *mrb, mrb_value klass)
     246{
     247  mrb_value ary;
    248248  mrb_value *vals;
    249249  mrb_int len;
     250  struct RArray *a;
    250251
    251252  mrb_get_args(mrb, "*", &vals, &len);
    252 
    253   return mrb_ary_new_from_values(mrb, len, vals);
     253  ary = mrb_ary_new_from_values(mrb, len, vals);
     254  a = mrb_ary_ptr(ary);
     255  a->c = mrb_class_ptr(klass);
     256
     257  return ary;
    254258}
    255259
    256260static void
    257 ary_concat(mrb_state *mrb, struct RArray *a, mrb_value *ptr, mrb_int blen)
    258 {
    259   mrb_int len = a->len + blen;
     261ary_concat(mrb_state *mrb, struct RArray *a, struct RArray *a2)
     262{
     263  mrb_int len;
     264
     265  if (a2->len > ARY_MAX_SIZE - a->len) {
     266    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
     267  }
     268  len = a->len + a2->len;
    260269
    261270  ary_modify(mrb, a);
    262   if (a->aux.capa < len) ary_expand_capa(mrb, a, len);
    263   array_copy(a->ptr+a->len, ptr, blen);
     271  if (a->aux.capa < len) {
     272    ary_expand_capa(mrb, a, len);
     273  }
     274  array_copy(a->ptr+a->len, a2->ptr, a2->len);
    264275  mrb_write_barrier(mrb, (struct RBasic*)a);
    265276  a->len = len;
    … …  
    271282  struct RArray *a2 = mrb_ary_ptr(other);
    272283
    273   ary_concat(mrb, mrb_ary_ptr(self), a2->ptr, a2->len);
     284  ary_concat(mrb, mrb_ary_ptr(self), a2);
    274285}
    275286
    … …  
    277288mrb_ary_concat_m(mrb_state *mrb, mrb_value self)
    278289{
    279   mrb_value *ptr;
    280   mrb_int blen;
    281 
    282   mrb_get_args(mrb, "a", &ptr, &blen);
    283   ary_concat(mrb, mrb_ary_ptr(self), ptr, blen);
     290  mrb_value ary;
     291
     292  mrb_get_args(mrb, "A", &ary);
     293  mrb_ary_concat(mrb, self, ary);
    284294  return self;
    285295}
    … …  
    319329mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other)
    320330{
     331  struct RArray *a1 = mrb_ary_ptr(self);
    321332  struct RArray *a2 = mrb_ary_ptr(other);
    322333
    323   ary_replace(mrb, mrb_ary_ptr(self), a2->ptr, a2->len);
     334  if (a1 != a2) {
     335    ary_replace(mrb, a1, a2->ptr, a2->len);
     336  }
    324337}
    325338
    … …  
    433446  struct RArray *a = mrb_ary_ptr(ary);
    434447
     448  ary_modify(mrb, a);
    435449  if (a->len == 0) return mrb_nil_value();
    436450  return a->ptr[--a->len];
    … …  
    445459  mrb_value val;
    446460
     461  ary_modify(mrb, a);
    447462  if (a->len == 0) return mrb_nil_value();
    448463  if (ARY_SHARED_P(a)) {
    … …  
    507522
    508523  mrb_get_args(mrb, "*", &vals, &len);
     524  if (len > ARY_MAX_SIZE - a->len) {
     525    mrb_raise(mrb, E_ARGUMENT_ERROR, "array size too big");
     526  }
    509527  if (ARY_SHARED_P(a)
    510528      && a->aux.shared->refcnt == 1 /* shared only referenced from this array */
    … …  
    564582}
    565583
     584static struct RArray*
     585ary_dup(mrb_state *mrb, struct RArray *a)
     586{
     587  struct RArray *d = ary_new_capa(mrb, a->len);
     588
     589  ary_replace(mrb, d, a->ptr, a->len);
     590  return d;
     591}
     592
    566593MRB_API mrb_value
    567594mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_value rpl)
    568595{
    569596  struct RArray *a = mrb_ary_ptr(ary);
    570   mrb_int tail, size;
    571597  const mrb_value *argv;
    572   mrb_int i, argc;
     598  mrb_int argc;
     599  mrb_int tail;
    573600
    574601  ary_modify(mrb, a);
    … …  
    584611    }
    585612  }
    586   if (a->len < len || a->len < head + len) {
     613  tail = head + len;
     614  if (a->len < len || a->len < tail) {
    587615    len = a->len - head;
    588616  }
    589   tail = head + len;
    590617
    591618  /* size check */
    … …  
    593620    argc = RARRAY_LEN(rpl);
    594621    argv = RARRAY_PTR(rpl);
     622    if (argv == a->ptr) {
     623      struct RArray *r;
     624
     625      if (argc > 32767) {
     626        mrb_raise(mrb, E_ARGUMENT_ERROR, "too big recursive splice");
     627      }
     628      r = ary_dup(mrb, a);
     629      argv = r->ptr;
     630    }
    595631  }
    596632  else {
    … …  
    598634    argv = &rpl;
    599635  }
    600   size = head + argc;
    601 
    602   if (tail < a->len) size += a->len - tail;
    603   if (size > a->aux.capa)
    604     ary_expand_capa(mrb, a, size);
    605 
    606   if (head > a->len) {
     636  if (head >= a->len) {
     637    if (head > ARY_MAX_SIZE - argc) {
     638      mrb_raisef(mrb, E_INDEX_ERROR, "index %S too big", mrb_fixnum_value(head));
     639    }
     640    len = head + argc;
     641    if (len > a->aux.capa) {
     642      ary_expand_capa(mrb, a, head + argc);
     643    }
    607644    ary_fill_with_nil(a->ptr + a->len, head - a->len);
    608   }
    609   else if (head < a->len) {
    610     value_move(a->ptr + head + argc, a->ptr + tail, a->len - tail);
    611   }
    612 
    613   for (i = 0; i < argc; i++) {
    614     *(a->ptr + head + i) = *(argv + i);
    615     mrb_field_write_barrier_value(mrb, (struct RBasic*)a, argv[i]);
    616   }
    617 
    618   a->len = size;
    619 
     645    if (argc > 0) {
     646      array_copy(a->ptr + head, argv, argc);
     647    }
     648    a->len = len;
     649  }
     650  else {
     651    mrb_int alen;
     652
     653    if (a->len - len > ARY_MAX_SIZE - argc) {
     654      mrb_raisef(mrb, E_INDEX_ERROR, "index %S too big", mrb_fixnum_value(a->len + argc - len));
     655    }
     656    alen = a->len + argc - len;
     657    if (alen > a->aux.capa) {
     658      ary_expand_capa(mrb, a, alen);
     659    }
     660
     661    if (len != argc) {
     662      tail = head + len;
     663      value_move(a->ptr + head + argc, a->ptr + tail, a->len - tail);
     664      a->len = alen;
     665    }
     666    if (argc > 0) {
     667      value_move(a->ptr + head, argv, argc);
     668    }
     669  }
     670  mrb_write_barrier(mrb, (struct RBasic*)a);
    620671  return ary;
    621672}
    … …  
    703754      /* a[n..m] */
    704755    case MRB_TT_RANGE:
    705       if (mrb_range_beg_len(mrb, index, &i, &len, a->len)) {
     756      if (mrb_range_beg_len(mrb, index, &i, &len, a->len, TRUE) == 1) {
    706757        return ary_subseq(mrb, a, i, len);
    707758      }
    … …  
    767818  mrb_int i, len;
    768819
     820  mrb_ary_modify(mrb, mrb_ary_ptr(self));
    769821  if (mrb_get_args(mrb, "oo|o", &v1, &v2, &v3) == 2) {
    770     switch (mrb_type(v1)) {
    771822    /* a[n..m] = v */
    772     case MRB_TT_RANGE:
    773       if (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self))) {
    774         mrb_ary_splice(mrb, self, i, len, v2);
    775       }
     823    switch (mrb_range_beg_len(mrb, v1, &i, &len, RARRAY_LEN(self), FALSE)) {
     824    case 0:                   /* not range */
     825      mrb_ary_set(mrb, self, aget_index(mrb, v1), v2);
    776826      break;
    777     /* a[n] = v */
    778     case MRB_TT_FIXNUM:
    779       mrb_ary_set(mrb, self, mrb_fixnum(v1), v2);
     827    case 1:                   /* range */
     828      mrb_ary_splice(mrb, self, i, len, v2);
    780829      break;
    781     default:
    782       mrb_ary_set(mrb, self, aget_index(mrb, v1), v2);
     830    case 2:                   /* out of range */
     831      mrb_raisef(mrb, E_RANGE_ERROR, "%S out of range", v1);
    783832      break;
    784833    }
    … …  
    878927{
    879928  mrb_value obj;
    880   mrb_int i;
     929  mrb_int i, len;
    881930
    882931  mrb_get_args(mrb, "o", &obj);
    … …  
    885934      return mrb_fixnum_value(i);
    886935    }
     936    if (i > (len = RARRAY_LEN(self))) {
     937      i = len;
     938    }
    887939  }
    888940  return mrb_nil_value();
    … …  
    892944mrb_ary_splat(mrb_state *mrb, mrb_value v)
    893945{
     946  mrb_value a, recv_class;
     947
    894948  if (mrb_array_p(v)) {
    895949    return v;
    896950  }
    897   if (mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) {
    898     return mrb_funcall(mrb, v, "to_a", 0);
     951
     952  if (!mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) {
     953    return mrb_ary_new_from_values(mrb, 1, &v);
     954  }
     955
     956  a = mrb_funcall(mrb, v, "to_a", 0);
     957  if (mrb_array_p(a)) {
     958    return a;
     959  }
     960  else if (mrb_nil_p(a)) {
     961    return mrb_ary_new_from_values(mrb, 1, &v);
    899962  }
    900963  else {
    901     return mrb_ary_new_from_values(mrb, 1, &v);
     964    recv_class = mrb_obj_value(mrb_obj_class(mrb, v));
     965    mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %S to Array (%S#to_a gives %S)",
     966      recv_class,
     967      recv_class,
     968      mrb_obj_value(mrb_obj_class(mrb, a))
     969    );
     970    /* not reached */
     971    return mrb_undef_value();
    902972  }
    903973}
    … …  
    916986  struct RArray *a = mrb_ary_ptr(self);
    917987
     988  ary_modify(mrb, a);
    918989  if (ARY_SHARED_P(a)) {
    919990    mrb_ary_decref(mrb, a->aux.shared);
    … …  
    9881059
    9891060    default:
    990       tmp = mrb_check_string_type(mrb, val);
    991       if (!mrb_nil_p(tmp)) {
    992         val = tmp;
    993         goto str_join;
    994       }
    995       tmp = mrb_check_convert_type(mrb, val, MRB_TT_ARRAY, "Array", "to_ary");
    996       if (!mrb_nil_p(tmp)) {
    997         val = tmp;
    998         goto ary_join;
     1061      if (!mrb_immediate_p(val)) {
     1062        tmp = mrb_check_string_type(mrb, val);
     1063        if (!mrb_nil_p(tmp)) {
     1064          val = tmp;
     1065          goto str_join;
     1066        }
     1067        tmp = mrb_check_convert_type(mrb, val, MRB_TT_ARRAY, "Array", "to_ary");
     1068        if (!mrb_nil_p(tmp)) {
     1069          val = tmp;
     1070          goto ary_join;
     1071        }
    9991072      }
    10001073      val = mrb_obj_as_string(mrb, val);
    … …  
    10111084mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep)
    10121085{
    1013   sep = mrb_obj_as_string(mrb, sep);
     1086  if (!mrb_nil_p(sep)) {
     1087    sep = mrb_obj_as_string(mrb, sep);
     1088  }
    10141089  return join_ary(mrb, ary, sep, mrb_ary_new(mrb));
    10151090}
    … …  
    10911166  mrb_define_method(mrb, a, "pop",             mrb_ary_pop,          MRB_ARGS_NONE()); /* 15.2.12.5.21 */
    10921167  mrb_define_method(mrb, a, "push",            mrb_ary_push_m,       MRB_ARGS_ANY());  /* 15.2.12.5.22 */
     1168  mrb_define_method(mrb, a, "append",          mrb_ary_push_m,       MRB_ARGS_ANY());
    10931169  mrb_define_method(mrb, a, "replace",         mrb_ary_replace_m,    MRB_ARGS_REQ(1)); /* 15.2.12.5.23 */
    10941170  mrb_define_method(mrb, a, "reverse",         mrb_ary_reverse,      MRB_ARGS_NONE()); /* 15.2.12.5.24 */
    … …  
    10991175  mrb_define_method(mrb, a, "slice",           mrb_ary_aget,         MRB_ARGS_ANY());  /* 15.2.12.5.29 */
    11001176  mrb_define_method(mrb, a, "unshift",         mrb_ary_unshift_m,    MRB_ARGS_ANY());  /* 15.2.12.5.30 */
     1177  mrb_define_method(mrb, a, "prepend",         mrb_ary_unshift_m,    MRB_ARGS_ANY());
    11011178
    11021179  mrb_define_method(mrb, a, "__ary_eq",        mrb_ary_eq,           MRB_ARGS_REQ(1));

  • EcnlProtoTool/trunk/mruby-1.3.0/src/backtrace.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/variable.h"
    9 #include "mruby/proc.h"
    10 #include "mruby/array.h"
    11 #include "mruby/string.h"
    12 #include "mruby/class.h"
    13 #include "mruby/debug.h"
    14 #include "mruby/error.h"
    15 #include "mruby/numeric.h"
     7#include <mruby.h>
     8#include <mruby/variable.h>
     9#include <mruby/proc.h>
     10#include <mruby/array.h>
     11#include <mruby/string.h>
     12#include <mruby/class.h>
     13#include <mruby/debug.h>
     14#include <mruby/error.h>
     15#include <mruby/numeric.h>
     16#include <mruby/data.h>
    1617
    1718struct backtrace_location {
    18   int i;
    1919  int lineno;
    2020  const char *filename;
    21   const char *method;
    22   const char *sep;
    23   const char *class_name;
     21  mrb_sym method_id;
    2422};
    2523
    26 typedef void (*output_stream_func)(mrb_state*, struct backtrace_location*, void*);
    27 
    28 #ifndef MRB_DISABLE_STDIO
    29 
    30 struct print_backtrace_args {
    31   FILE *stream;
    32   int tracehead;
    33 };
    34 
    35 static void
    36 print_backtrace_i(mrb_state *mrb, struct backtrace_location *loc, void *data)
    37 {
    38   struct print_backtrace_args *args;
    39 
    40   args = (struct print_backtrace_args*)data;
    41 
    42   if (args->tracehead) {
    43     fprintf(args->stream, "trace:\n");
    44     args->tracehead = FALSE;
    45   }
    46 
    47   fprintf(args->stream, "\t[%d] %s:%d", loc->i, loc->filename, loc->lineno);
    48 
    49   if (loc->method) {
    50     if (loc->class_name) {
    51       fprintf(args->stream, ":in %s%s%s", loc->class_name, loc->sep, loc->method);
    52     }
    53     else {
    54       fprintf(args->stream, ":in %s", loc->method);
    55     }
    56   }
    57 
    58   fprintf(args->stream, "\n");
    59 }
    60 
    61 #endif
    62 
    63 static void
    64 get_backtrace_i(mrb_state *mrb, struct backtrace_location *loc, void *data)
    65 {
    66   mrb_value ary, str;
    67   int ai;
    68 
    69   ai = mrb_gc_arena_save(mrb);
    70   ary = mrb_obj_value((struct RArray*)data);
    71 
    72   str = mrb_str_new_cstr(mrb, loc->filename);
    73   mrb_str_cat_lit(mrb, str, ":");
    74   mrb_str_concat(mrb, str, mrb_fixnum_to_str(mrb, mrb_fixnum_value(loc->lineno), 10));
    75 
    76   if (loc->method) {
    77     mrb_str_cat_lit(mrb, str, ":in ");
    78 
    79     if (loc->class_name) {
    80       mrb_str_cat_cstr(mrb, str, loc->class_name);
    81       mrb_str_cat_cstr(mrb, str, loc->sep);
    82     }
    83 
    84     mrb_str_cat_cstr(mrb, str, loc->method);
    85   }
    86 
    87   mrb_ary_push(mrb, ary, str);
    88   mrb_gc_arena_restore(mrb, ai);
    89 }
    90 
    91 static void
    92 output_backtrace(mrb_state *mrb, mrb_int ciidx, mrb_code *pc0, output_stream_func func, void *data)
    93 {
    94   int i;
     24typedef void (*each_backtrace_func)(mrb_state*, int i, struct backtrace_location*, void*);
     25
     26static const mrb_data_type bt_type = { "Backtrace", mrb_free };
     27
     28static void
     29each_backtrace(mrb_state *mrb, mrb_int ciidx, mrb_code *pc0, each_backtrace_func func, void *data)
     30{
     31  int i, j;
    9532
    9633  if (ciidx >= mrb->c->ciend - mrb->c->cibase)
    9734    ciidx = 10; /* ciidx is broken... */
    9835
    99   for (i = ciidx; i >= 0; i--) {
     36  for (i=ciidx, j=0; i >= 0; i--,j++) {
    10037    struct backtrace_location loc;
    10138    mrb_callinfo *ci;
    … …  
    10946
    11047    irep = ci->proc->body.irep;
     48    if (!irep) continue;
    11149
    11250    if (mrb->c->cibase[i].err) {
    … …  
    12462    if (loc.lineno == -1) continue;
    12563
    126     if (ci->target_class == ci->proc->target_class) {
    127       loc.sep = ".";
    128     }
    129     else {
    130       loc.sep = "#";
    131     }
    132 
    13364    if (!loc.filename) {
    13465      loc.filename = "(unknown)";
    13566    }
    13667
    137     loc.method = mrb_sym2name(mrb, ci->mid);
    138     loc.class_name = mrb_class_name(mrb, ci->proc->target_class);
    139     loc.i = i;
    140     func(mrb, &loc, data);
    141   }
    142 }
    143 
    144 static void
    145 exc_output_backtrace(mrb_state *mrb, struct RObject *exc, output_stream_func func, void *stream)
    146 {
    147   mrb_value lastpc;
    148   mrb_code *code;
    149 
    150   lastpc = mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "lastpc"));
    151   if (mrb_nil_p(lastpc)) {
    152     code = NULL;
    153   } else {
    154     code = (mrb_code*)mrb_cptr(lastpc);
    155   }
    156 
    157   output_backtrace(mrb, mrb_fixnum(mrb_obj_iv_get(mrb, exc, mrb_intern_lit(mrb, "ciidx"))),
    158                    code, func, stream);
    159 }
    160 
    161 /* mrb_print_backtrace/mrb_get_backtrace:
    162 
    163    function to retrieve backtrace information from the exception.
    164    note that if you call method after the exception, call stack will be
    165    overwritten.  So invoke these functions just after detecting exceptions.
     68    loc.method_id = ci->mid;
     69    func(mrb, j, &loc, data);
     70  }
     71}
     72
     73#ifndef MRB_DISABLE_STDIO
     74
     75static void
     76print_backtrace(mrb_state *mrb, mrb_value backtrace)
     77{
     78  int i, n;
     79  FILE *stream = stderr;
     80
     81  if (!mrb_array_p(backtrace)) return;
     82  fprintf(stream, "trace:\n");
     83
     84  n = RARRAY_LEN(backtrace);
     85  for (i=0; n--; i++) {
     86    mrb_value entry = RARRAY_PTR(backtrace)[n];
     87
     88    if (mrb_string_p(entry)) {
     89      fprintf(stream, "\t[%d] %.*s\n", i, (int)RSTRING_LEN(entry), RSTRING_PTR(entry));
     90    }
     91  }
     92}
     93
     94static void
     95print_packed_backtrace(mrb_state *mrb, mrb_value packed)
     96{
     97  FILE *stream = stderr;
     98  struct backtrace_location *bt;
     99  int n, i;
     100
     101  bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, packed, &bt_type);
     102  if (bt == NULL) {
     103    mrb_raise(mrb, E_RUNTIME_ERROR, "broken backtrace");
     104  }
     105  n = (mrb_int)RDATA(packed)->flags;
     106
     107  fprintf(stream, "trace:\n");
     108  for (i = 0; n--; i++) {
     109    int ai = mrb_gc_arena_save(mrb);
     110    struct backtrace_location *entry = &bt[n];
     111    if (entry->filename == NULL) continue;
     112    fprintf(stream, "\t[%d] %s:%d", (int)i, entry->filename, entry->lineno);
     113    if (entry->method_id != 0) {
     114      const char *method_name;
     115
     116      method_name = mrb_sym2name(mrb, entry->method_id);
     117      fprintf(stream, ":in %s", method_name);
     118      mrb_gc_arena_restore(mrb, ai);
     119    }
     120    fprintf(stream, "\n");
     121  }
     122}
     123
     124/* mrb_print_backtrace
     125
     126   function to retrieve backtrace information from the last exception.
    166127*/
    167 
    168 #ifndef MRB_DISABLE_STDIO
    169128
    170129MRB_API void
    171130mrb_print_backtrace(mrb_state *mrb)
    172131{
    173   struct print_backtrace_args args;
    174 
    175   if (!mrb->exc || mrb_obj_is_kind_of(mrb, mrb_obj_value(mrb->exc), E_SYSSTACK_ERROR)) {
     132  mrb_value backtrace;
     133
     134  if (!mrb->exc) {
    176135    return;
    177136  }
    178137
    179   args.stream = stderr;
    180   args.tracehead = TRUE;
    181   exc_output_backtrace(mrb, mrb->exc, print_backtrace_i, (void*)&args);
    182 }
    183 
     138  backtrace = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "backtrace"));
     139  if (mrb_nil_p(backtrace)) return;
     140  if (mrb_array_p(backtrace)) {
     141    print_backtrace(mrb, backtrace);
     142  }
     143  else {
     144    print_packed_backtrace(mrb, backtrace);
     145  }
     146}
    184147#else
    185148
    … …  
    191154#endif
    192155
     156static void
     157pack_backtrace_i(mrb_state *mrb,
     158                 int i,
     159                 struct backtrace_location *loc,
     160                 void *data)
     161{
     162  struct backtrace_location *entry = (struct backtrace_location*)data;
     163
     164  entry[i] = *loc;
     165}
     166
     167static mrb_value
     168packed_backtrace(mrb_state *mrb)
     169{
     170  struct RData *backtrace;
     171  ptrdiff_t ciidx = mrb->c->ci - mrb->c->cibase;
     172  mrb_int len = (ciidx+1)*sizeof(struct backtrace_location);
     173  void *ptr;
     174
     175  ptr = mrb_malloc(mrb, len);
     176  memset(ptr, 0, len);
     177  backtrace = mrb_data_object_alloc(mrb, NULL, ptr, &bt_type);
     178  backtrace->flags = (unsigned int)ciidx+1;
     179  each_backtrace(mrb, ciidx, mrb->c->ci->pc, pack_backtrace_i, ptr);
     180  return mrb_obj_value(backtrace);
     181}
     182
     183void
     184mrb_keep_backtrace(mrb_state *mrb, mrb_value exc)
     185{
     186  mrb_value backtrace;
     187  int ai = mrb_gc_arena_save(mrb);
     188
     189  backtrace = packed_backtrace(mrb);
     190  mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "backtrace"), backtrace);
     191  mrb_gc_arena_restore(mrb, ai);
     192}
     193
     194mrb_value
     195mrb_unpack_backtrace(mrb_state *mrb, mrb_value backtrace)
     196{
     197  struct backtrace_location *bt;
     198  mrb_int n, i;
     199
     200  if (mrb_nil_p(backtrace)) return mrb_ary_new_capa(mrb, 0);
     201  if (mrb_array_p(backtrace)) return backtrace;
     202  bt = (struct backtrace_location*)mrb_data_check_get_ptr(mrb, backtrace, &bt_type);
     203  if (bt == NULL) {
     204    mrb_raise(mrb, E_RUNTIME_ERROR, "broken backtrace");
     205  }
     206  n = (mrb_int)RDATA(backtrace)->flags;
     207  backtrace = mrb_ary_new_capa(mrb, n);
     208  for (i = 0; i < n; i++) {
     209    int ai = mrb_gc_arena_save(mrb);
     210    struct backtrace_location *entry = &bt[i];
     211    mrb_value btline;
     212
     213    if (entry->filename == NULL) continue;
     214    btline = mrb_format(mrb, "%S:%S",
     215                              mrb_str_new_cstr(mrb, entry->filename),
     216                              mrb_fixnum_value(entry->lineno));
     217    if (entry->method_id != 0) {
     218      mrb_str_cat_lit(mrb, btline, ":in ");
     219      mrb_str_cat_cstr(mrb, btline, mrb_sym2name(mrb, entry->method_id));
     220    }
     221    mrb_ary_push(mrb, backtrace, btline);
     222    mrb_gc_arena_restore(mrb, ai);
     223  }
     224
     225  return backtrace;
     226}
     227
    193228MRB_API mrb_value
    194 mrb_exc_backtrace(mrb_state *mrb, mrb_value self)
    195 {
    196   mrb_value ary;
    197 
    198   ary = mrb_ary_new(mrb);
    199   exc_output_backtrace(mrb, mrb_obj_ptr(self), get_backtrace_i, (void*)mrb_ary_ptr(ary));
    200 
    201   return ary;
     229mrb_exc_backtrace(mrb_state *mrb, mrb_value exc)
     230{
     231  mrb_sym attr_name;
     232  mrb_value backtrace;
     233
     234  attr_name = mrb_intern_lit(mrb, "backtrace");
     235  backtrace = mrb_iv_get(mrb, exc, attr_name);
     236  if (mrb_nil_p(backtrace) || mrb_array_p(backtrace)) {
     237    return backtrace;
     238  }
     239  backtrace = mrb_unpack_backtrace(mrb, backtrace);
     240  mrb_iv_set(mrb, exc, attr_name, backtrace);
     241  return backtrace;
    202242}
    203243
    … …  
    205245mrb_get_backtrace(mrb_state *mrb)
    206246{
    207   mrb_value ary;
    208   mrb_callinfo *ci = mrb->c->ci;
    209   mrb_code *pc = ci->pc;
    210   mrb_int ciidx = (mrb_int)(ci - mrb->c->cibase - 1);
    211 
    212   if (ciidx < 0) ciidx = 0;
    213   ary = mrb_ary_new(mrb);
    214   output_backtrace(mrb, ciidx, pc, get_backtrace_i, (void*)mrb_ary_ptr(ary));
    215 
    216   return ary;
    217 }
     247  return mrb_unpack_backtrace(mrb, packed_backtrace(mrb));
     248}

  • EcnlProtoTool/trunk/mruby-1.3.0/src/class.c

    r321 r331  
    66
    77#include <stdarg.h>
    8 #include "mruby.h"
    9 #include "mruby/array.h"
    10 #include "mruby/class.h"
    11 #include "mruby/numeric.h"
    12 #include "mruby/proc.h"
    13 #include "mruby/string.h"
    14 #include "mruby/variable.h"
    15 #include "mruby/error.h"
    16 #include "mruby/data.h"
     8#include <mruby.h>
     9#include <mruby/array.h>
     10#include <mruby/class.h>
     11#include <mruby/numeric.h>
     12#include <mruby/proc.h>
     13#include <mruby/string.h>
     14#include <mruby/variable.h>
     15#include <mruby/error.h>
     16#include <mruby/data.h>
     17#include <mruby/istruct.h>
    1718
    1819KHASH_DEFINE(mt, mrb_sym, struct RProc*, TRUE, kh_int_hash_func, kh_int_hash_equal)
    … …  
    9798  else {
    9899    sc->super = o->c;
     100    prepare_singleton_class(mrb, (struct RBasic*)sc);
    99101  }
    100102  o->c = sc;
    … …  
    122124}
    123125
    124 MRB_API struct RClass*
    125 mrb_class_outer_module(mrb_state *mrb, struct RClass *c)
    126 {
    127   mrb_value outer;
    128 
    129   outer = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"));
    130   if (mrb_nil_p(outer)) return NULL;
    131   return mrb_class_ptr(outer);
    132 }
    133 
    134 static void
    135 check_if_class_or_module(mrb_state *mrb, mrb_value obj)
     126static mrb_bool
     127class_ptr_p(mrb_value obj)
    136128{
    137129  switch (mrb_type(obj)) {
    … …  
    139131  case MRB_TT_SCLASS:
    140132  case MRB_TT_MODULE:
    141     return;
     133    return TRUE;
    142134  default:
     135    return FALSE;
     136  }
     137}
     138
     139MRB_API struct RClass*
     140mrb_class_outer_module(mrb_state *mrb, struct RClass *c)
     141{
     142  mrb_value outer;
     143  struct RClass *cls;
     144
     145  outer = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"));
     146  if (mrb_nil_p(outer)) return NULL;
     147  cls = mrb_class_ptr(outer);
     148  if (cls->tt == MRB_TT_SCLASS)
     149  {
     150    mrb_value klass;
     151    klass = mrb_obj_iv_get(mrb, (struct RObject *)cls,
     152                           mrb_intern_lit(mrb, "__attached__"));
     153    if (class_ptr_p(klass)) {
     154      cls = mrb_class_ptr(klass);
     155    }
     156  }
     157  return cls;
     158}
     159
     160static void
     161check_if_class_or_module(mrb_state *mrb, mrb_value obj)
     162{
     163  if (!class_ptr_p(obj)) {
    143164    mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a class/module", mrb_inspect(mrb, obj));
    144165  }
    … …  
    175196{
    176197  check_if_class_or_module(mrb, outer);
     198  if (mrb_const_defined_at(mrb, outer, id)) {
     199    mrb_value old = mrb_const_get(mrb, outer, id);
     200
     201    if (mrb_type(old) != MRB_TT_MODULE) {
     202      mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a module", mrb_inspect(mrb, old));
     203    }
     204    return mrb_class_ptr(old);
     205  }
    177206  return define_module(mrb, id, mrb_class_ptr(outer));
    178207}
    … …  
    232261}
    233262
     263static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value cv);
     264
    234265static void
    235266mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass)
    236267{
     268  mrb_value s;
     269  mrb_sym mid;
     270
    237271  if (!super)
    238272    super = mrb->object_class;
    239   mrb_funcall(mrb, mrb_obj_value(super), "inherited", 1, mrb_obj_value(klass));
     273  s = mrb_obj_value(super);
     274  mid = mrb_intern_lit(mrb, "inherited");
     275  if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) {
     276    mrb_value c = mrb_obj_value(klass);
     277    mrb_funcall_argv(mrb, mrb_obj_value(super), mid, 1, &c);
     278  }
    240279}
    241280
    … …  
    248287  if (!mrb_nil_p(super)) {
    249288    if (mrb_type(super) != MRB_TT_CLASS) {
    250       mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%S given)", super);
     289      mrb_raisef(mrb, E_TYPE_ERROR, "superclass must be a Class (%S given)",
     290                 mrb_inspect(mrb, super));
    251291    }
    252292    s = mrb_class_ptr(super);
    … …  
    256296  }
    257297  check_if_class_or_module(mrb, outer);
     298  if (mrb_const_defined_at(mrb, outer, id)) {
     299    mrb_value old = mrb_const_get(mrb, outer, id);
     300
     301    if (mrb_type(old) != MRB_TT_CLASS) {
     302      mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a class", mrb_inspect(mrb, old));
     303    }
     304    c = mrb_class_ptr(old);
     305    if (s) {
     306      /* check super class */
     307      if (mrb_class_real(c->super) != s) {
     308        mrb_raisef(mrb, E_TYPE_ERROR, "superclass mismatch for class %S", old);
     309      }
     310    }
     311    return c;
     312  }
    258313  c = define_class(mrb, id, s, mrb_class_ptr(outer));
    259314  mrb_class_inherited(mrb, mrb_class_real(c->super), c);
    … …  
    272327}
    273328
     329MRB_API mrb_bool
     330mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name)
     331{
     332  mrb_value sym = mrb_check_intern_cstr(mrb, name);
     333  if (mrb_nil_p(sym)) {
     334    return FALSE;
     335  }
     336  return mrb_const_defined_at(mrb, mrb_obj_value(outer), mrb_symbol(sym));
     337}
     338
    274339MRB_API struct RClass *
    275340mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
    … …  
    282347{
    283348  return mrb_class_get_under(mrb, mrb->object_class, name);
     349}
     350
     351MRB_API struct RClass *
     352mrb_exc_get(mrb_state *mrb, const char *name)
     353{
     354  struct RClass *exc, *e;
     355  mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class),
     356                              mrb_intern_cstr(mrb, name));
     357
     358  if (mrb_type(c) != MRB_TT_CLASS) {
     359    mrb_raise(mrb, mrb->eException_class, "exception corrupted");
     360  }
     361  exc = e = mrb_class_ptr(c);
     362
     363  while (e) {
     364    if (e == mrb->eException_class)
     365      return exc;
     366    e = e->super;
     367  }
     368  return mrb->eException_class;
    284369}
    285370
    … …  
    337422  h = c->mt;
    338423
     424  if (MRB_FROZEN_P(c)) {
     425    if (c->tt == MRB_TT_MODULE)
     426      mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen module");
     427    else
     428      mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen class");
     429  }
    339430  if (!h) h = c->mt = kh_init(mt, mrb);
    340431  k = kh_put(mt, mrb, h, mid);
    341432  kh_value(h, k) = p;
    342433  if (p) {
     434    p->c = NULL;
    343435    mrb_field_write_barrier(mrb, (struct RBasic *)c, (struct RBasic *)p);
    344436  }
    … …  
    430522    mrb_value obj = mrb_funcall(mrb, ss, "inspect", 0);
    431523    mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", obj);
     524    /* not reached */
     525    return 0;
    432526  }
    433527}
    … …  
    457551    n:      Symbol         [mrb_sym]
    458552    d:      Data           [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified
     553    I:      Inline struct  [void*]
    459554    &:      Block          [mrb_value]
    460555    *:      rest argument  [mrb_value*,mrb_int]   Receive the rest of the arguments as an array.
    … …  
    467562  char c;
    468563  int i = 0;
    469   mrb_value *sp = mrb->c->stack + 1;
    470564  va_list ap;
    471565  int argc = mrb->c->ci->argc;
     566  int arg_i = 0;
     567  mrb_bool array_argv;
    472568  mrb_bool opt = FALSE;
    473569  mrb_bool given = TRUE;
    … …  
    478574
    479575    argc = a->len;
    480     sp = a->ptr;
    481   }
     576    array_argv = TRUE;
     577  }
     578  else {
     579    array_argv = FALSE;
     580  }
     581
     582#define ARGV \
     583  (array_argv ? mrb_ary_ptr(mrb->c->stack[1])->ptr : (mrb->c->stack + 1))
     584
    482585  while ((c = *format++)) {
    483586    switch (c) {
    … …  
    503606        p = va_arg(ap, mrb_value*);
    504607        if (i < argc) {
    505           *p = *sp++;
     608          *p = ARGV[arg_i++];
    506609          i++;
    507610        }
    … …  
    516619          mrb_value ss;
    517620
    518           ss = *sp++;
    519           switch (mrb_type(ss)) {
    520           case MRB_TT_CLASS:
    521           case MRB_TT_MODULE:
    522           case MRB_TT_SCLASS:
    523             break;
    524           default:
     621          ss = ARGV[arg_i++];
     622          if (!class_ptr_p(ss)) {
    525623            mrb_raisef(mrb, E_TYPE_ERROR, "%S is not class/module", ss);
    526             break;
    527624          }
    528625          *p = ss;
    … …  
    538635        if (*format == '!') {
    539636          format++;
    540           if (i < argc && mrb_nil_p(*sp)) {
    541             *p = *sp++;
     637          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
     638            *p = ARGV[arg_i++];
    542639            i++;
    543640            break;
    … …  
    545642        }
    546643        if (i < argc) {
    547           *p = to_str(mrb, *sp++);
     644          *p = to_str(mrb, ARGV[arg_i++]);
    548645          i++;
    549646        }
    … …  
    557654        if (*format == '!') {
    558655          format++;
    559           if (i < argc && mrb_nil_p(*sp)) {
    560             *p = *sp++;
     656          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
     657            *p = ARGV[arg_i++];
    561658            i++;
    562659            break;
    … …  
    564661        }
    565662        if (i < argc) {
    566           *p = to_ary(mrb, *sp++);
     663          *p = to_ary(mrb, ARGV[arg_i++]);
    567664          i++;
    568665        }
    … …  
    576673        if (*format == '!') {
    577674          format++;
    578           if (i < argc && mrb_nil_p(*sp)) {
    579             *p = *sp++;
     675          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
     676            *p = ARGV[arg_i++];
    580677            i++;
    581678            break;
    … …  
    583680        }
    584681        if (i < argc) {
    585           *p = to_hash(mrb, *sp++);
     682          *p = to_hash(mrb, ARGV[arg_i++]);
    586683          i++;
    587684        }
    … …  
    598695        if (*format == '!') {
    599696          format++;
    600           if (i < argc && mrb_nil_p(*sp)) {
     697          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
    601698            *ps = NULL;
    602699            *pl = 0;
    603             i++;
     700            i++; arg_i++;
    604701            break;
    605702          }
    606703        }
    607704        if (i < argc) {
    608           ss = to_str(mrb, *sp++);
     705          ss = to_str(mrb, ARGV[arg_i++]);
    609706          *ps = RSTRING_PTR(ss);
    610707          *pl = RSTRING_LEN(ss);
    … …  
    621718        if (*format == '!') {
    622719          format++;
    623           if (i < argc && mrb_nil_p(*sp)) {
     720          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
    624721            *ps = NULL;
    625             i++; sp++;
     722            i++; arg_i++;
    626723            break;
    627724          }
    628725        }
    629726        if (i < argc) {
    630           ss = to_str(mrb, *sp++);
     727          ss = to_str(mrb, ARGV[arg_i++]);
    631728          *ps = mrb_string_value_cstr(mrb, &ss);
    632729          i++;
    … …  
    645742        if (*format == '!') {
    646743          format++;
    647           if (i < argc && mrb_nil_p(*sp)) {
     744          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
    648745            *pb = 0;
    649746            *pl = 0;
    650             i++; sp++;
     747            i++; arg_i++;
    651748            break;
    652749          }
    653750        }
    654751        if (i < argc) {
    655           aa = to_ary(mrb, *sp++);
     752          aa = to_ary(mrb, ARGV[arg_i++]);
    656753          a = mrb_ary_ptr(aa);
    657754          *pb = a->ptr;
    … …  
    661758      }
    662759      break;
     760    case 'I':
     761      {
     762        void* *p;
     763        mrb_value ss;
     764
     765        p = va_arg(ap, void**);
     766        if (i < argc) {
     767          ss = ARGV[arg_i];
     768          if (mrb_type(ss) != MRB_TT_ISTRUCT)
     769          {
     770            mrb_raisef(mrb, E_TYPE_ERROR, "%S is not inline struct", ss);
     771          }
     772          *p = mrb_istruct_ptr(ss);
     773          arg_i++;
     774          i++;
     775        }
     776      }
     777      break;
    663778    case 'f':
    664779      {
    … …  
    667782        p = va_arg(ap, mrb_float*);
    668783        if (i < argc) {
    669           *p = mrb_to_flo(mrb, *sp);
    670           sp++;
     784          *p = mrb_to_flo(mrb, ARGV[arg_i]);
     785          arg_i++;
    671786          i++;
    672787        }
    … …  
    679794        p = va_arg(ap, mrb_int*);
    680795        if (i < argc) {
    681           switch (mrb_type(*sp)) {
     796          switch (mrb_type(ARGV[arg_i])) {
    682797            case MRB_TT_FIXNUM:
    683               *p = mrb_fixnum(*sp);
     798              *p = mrb_fixnum(ARGV[arg_i]);
    684799              break;
    685800            case MRB_TT_FLOAT:
    686801              {
    687                 mrb_float f = mrb_float(*sp);
    688 
    689                 if (!FIXABLE(f)) {
     802                mrb_float f = mrb_float(ARGV[arg_i]);
     803
     804                if (!FIXABLE_FLOAT(f)) {
    690805                  mrb_raise(mrb, E_RANGE_ERROR, "float too big for int");
    691806                }
    … …  
    697812              break;
    698813            default:
    699               *p = mrb_fixnum(mrb_Integer(mrb, *sp));
     814              *p = mrb_fixnum(mrb_Integer(mrb, ARGV[arg_i]));
    700815              break;
    701816          }
    702           sp++;
     817          arg_i++;
    703818          i++;
    704819        }
    … …  
    710825
    711826        if (i < argc) {
    712           mrb_value b = *sp++;
     827          mrb_value b = ARGV[arg_i++];
    713828          *boolp = mrb_test(b);
    714829          i++;
    … …  
    724839          mrb_value ss;
    725840
    726           ss = *sp++;
     841          ss = ARGV[arg_i++];
    727842          *symp = to_sym(mrb, ss);
    728843          i++;
    … …  
    739854        if (*format == '!') {
    740855          format++;
    741           if (i < argc && mrb_nil_p(*sp)) {
     856          if (i < argc && mrb_nil_p(ARGV[arg_i])) {
    742857            *datap = 0;
    743             i++; sp++;
     858            i++; arg_i++;
    744859            break;
    745860          }
    746861        }
    747862        if (i < argc) {
    748           *datap = mrb_data_get_ptr(mrb, *sp++, type);
     863          *datap = mrb_data_get_ptr(mrb, ARGV[arg_i++], type);
    749864          ++i;
    750865        }
    … …  
    788903          *pl = argc-i;
    789904          if (*pl > 0) {
    790             *var = sp;
     905            *var = ARGV + arg_i;
    791906          }
    792907          i = argc;
    793           sp += *pl;
     908          arg_i += *pl;
    794909        }
    795910        else {
    … …  
    804919    }
    805920  }
     921
     922#undef ARGV
     923
    806924  if (!c && argc > i) {
    807925    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
    … …  
    831949boot_initmod(mrb_state *mrb, struct RClass *mod)
    832950{
    833   mod->mt = kh_init(mt, mrb);
     951  if (!mod->mt) {
     952    mod->mt = kh_init(mt, mrb);
     953  }
    834954}
    835955
    … …  
    847967  if (m->tt == MRB_TT_ICLASS) {
    848968    ic->c = m->c;
    849   } else {
     969  }
     970  else {
    850971    ic->c = m;
    851972  }
    … …  
    873994        if (p->mt == m->mt) {
    874995          if (!superclass_seen) {
    875             ins_pos = p; // move insert point
     996            ins_pos = p; /* move insert point */
    876997          }
    877998          goto skip;
    … …  
    9371058
    9381059static mrb_value
    939 mrb_mod_prepend(mrb_state *mrb, mrb_value klass)
    940 {
    941   mrb_value *argv;
    942   mrb_int argc, i;
    943 
    944   mrb_get_args(mrb, "*", &argv, &argc);
    945   for (i=0; i<argc; i++) {
    946     mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
    947   }
    948   while (argc--) {
    949     mrb_funcall(mrb, argv[argc], "prepend_features", 1, klass);
    950     mrb_funcall(mrb, argv[argc], "prepended", 1, klass);
    951   }
    952 
    953   return klass;
    954 }
    955 
    956 static mrb_value
    9571060mrb_mod_append_features(mrb_state *mrb, mrb_value mod)
    9581061{
    … …  
    9631066  mrb_include_module(mrb, mrb_class_ptr(klass), mrb_class_ptr(mod));
    9641067  return mod;
    965 }
    966 
    967 static mrb_value
    968 mrb_mod_include(mrb_state *mrb, mrb_value klass)
    969 {
    970   mrb_value *argv;
    971   mrb_int argc, i;
    972 
    973   mrb_get_args(mrb, "*", &argv, &argc);
    974   for (i=0; i<argc; i++) {
    975     mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
    976   }
    977   while (argc--) {
    978     mrb_funcall(mrb, argv[argc], "append_features", 1, klass);
    979     mrb_funcall(mrb, argv[argc], "included", 1, klass);
    980   }
    981 
    982   return klass;
    9831068}
    9841069
    … …  
    10761161  mrb_value b;
    10771162  struct RClass *m = mrb_class_ptr(mod);
    1078   boot_initmod(mrb, m); // bootstrap a newly initialized module
     1163  boot_initmod(mrb, m); /* bootstrap a newly initialized module */
    10791164  mrb_get_args(mrb, "|&", &b);
    10801165  if (!mrb_nil_p(b)) {
    … …  
    11561241  obj = mrb_basic_ptr(v);
    11571242  prepare_singleton_class(mrb, obj);
    1158   if (mrb->c && mrb->c->ci && mrb->c->ci->target_class) {
    1159     mrb_obj_iv_set(mrb, (struct RObject*)obj->c, mrb_intern_lit(mrb, "__outer__"),
    1160                    mrb_obj_value(mrb->c->ci->target_class));
    1161   }
    11621243  return mrb_obj_value(obj->c);
    11631244}
    … …  
    13201401
    13211402  if (ttype == 0) ttype = MRB_TT_OBJECT;
     1403  if (ttype <= MRB_TT_CPTR) {
     1404    mrb_raisef(mrb, E_TYPE_ERROR, "can't create instance of %S", cv);
     1405  }
    13221406  o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
    13231407  return mrb_obj_value(o);
    … …  
    13541438{
    13551439  mrb_value obj;
     1440  mrb_sym mid;
    13561441
    13571442  obj = mrb_instance_alloc(mrb, mrb_obj_value(c));
    1358   mrb_funcall_argv(mrb, obj, mrb_intern_lit(mrb, "initialize"), argc, argv);
    1359 
     1443  mid = mrb_intern_lit(mrb, "initialize");
     1444  if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) {
     1445    mrb_funcall_argv(mrb, obj, mid, argc, argv);
     1446  }
    13601447  return obj;
    13611448}
    … …  
    13791466  mrb_value super, blk;
    13801467  mrb_value new_class;
     1468  mrb_sym mid;
    13811469
    13821470  n = mrb_get_args(mrb, "|C&", &super, &blk);
    … …  
    13851473  }
    13861474  new_class = mrb_obj_value(mrb_class_new(mrb, mrb_class_ptr(super)));
    1387   mrb_funcall_with_block(mrb, new_class, mrb_intern_lit(mrb, "initialize"), n, &super, blk);
     1475  mid = mrb_intern_lit(mrb, "initialize");
     1476  if (!mrb_func_basic_p(mrb, new_class, mid, mrb_bob_init)) {
     1477    mrb_funcall_with_block(mrb, new_class, mid, n, &super, blk);
     1478  }
    13881479  mrb_class_inherited(mrb, mrb_class_ptr(super), mrb_class_ptr(new_class));
    13891480  return new_class;
    … …  
    14161507}
    14171508
    1418 void
    1419 mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args)
    1420 {
    1421   mrb_sym inspect;
    1422   mrb_value repr;
    1423 
    1424   inspect = mrb_intern_lit(mrb, "inspect");
    1425   if (mrb->c->ci > mrb->c->cibase && mrb->c->ci[-1].mid == inspect) {
    1426     /* method missing in inspect; avoid recursion */
    1427     repr = mrb_any_to_s(mrb, self);
    1428   }
    1429   else if (mrb_respond_to(mrb, self, inspect) && mrb->c->ci - mrb->c->cibase < 64) {
    1430     repr = mrb_funcall_argv(mrb, self, inspect, 0, 0);
    1431     if (mrb_string_p(repr) && RSTRING_LEN(repr) > 64) {
    1432       repr = mrb_any_to_s(mrb, self);
    1433     }
    1434   }
    1435   else {
    1436     repr = mrb_any_to_s(mrb, self);
    1437   }
    1438 
    1439   mrb_no_method_error(mrb, name, args, "undefined method '%S' for %S",
    1440                       mrb_sym2str(mrb, name), repr);
    1441 }
    1442 
    1443 /* 15.3.1.3.30 */
     1509/* 15.3.1.3.1  */
     1510/* 15.3.1.3.10 */
     1511/* 15.3.1.3.11 */
    14441512/*
    14451513 *  call-seq:
    1446  *     obj.method_missing(symbol [, *args] )   -> result
    1447  *
    1448  *  Invoked by Ruby when <i>obj</i> is sent a message it cannot handle.
    1449  *  <i>symbol</i> is the symbol for the method called, and <i>args</i>
    1450  *  are any arguments that were passed to it. By default, the interpreter
    1451  *  raises an error when this method is called. However, it is possible
    1452  *  to override the method to provide more dynamic behavior.
    1453  *  If it is decided that a particular method should not be handled, then
    1454  *  <i>super</i> should be called, so that ancestors can pick up the
    1455  *  missing method.
    1456  *  The example below creates
    1457  *  a class <code>Roman</code>, which responds to methods with names
    1458  *  consisting of roman numerals, returning the corresponding integer
    1459  *  values.
    1460  *
    1461  *     class Roman
    1462  *       def romanToInt(str)
    1463  *         # ...
    1464  *       end
    1465  *       def method_missing(methId)
    1466  *         str = methId.id2name
    1467  *         romanToInt(str)
    1468  *       end
    1469  *     end
    1470  *
    1471  *     r = Roman.new
    1472  *     r.iv      #=> 4
    1473  *     r.xxiii   #=> 23
    1474  *     r.mm      #=> 2000
     1514 *     obj == other        -> true or false
     1515 *     obj.equal?(other)   -> true or false
     1516 *     obj.eql?(other)     -> true or false
     1517 *
     1518 *  Equality---At the <code>Object</code> level, <code>==</code> returns
     1519 *  <code>true</code> only if <i>obj</i> and <i>other</i> are the
     1520 *  same object. Typically, this method is overridden in descendant
     1521 *  classes to provide class-specific meaning.
     1522 *
     1523 *  Unlike <code>==</code>, the <code>equal?</code> method should never be
     1524 *  overridden by subclasses: it is used to determine object identity
     1525 *  (that is, <code>a.equal?(b)</code> iff <code>a</code> is the same
     1526 *  object as <code>b</code>).
     1527 *
     1528 *  The <code>eql?</code> method returns <code>true</code> if
     1529 *  <i>obj</i> and <i>anObject</i> have the same value. Used by
     1530 *  <code>Hash</code> to test members for equality.  For objects of
     1531 *  class <code>Object</code>, <code>eql?</code> is synonymous with
     1532 *  <code>==</code>. Subclasses normally continue this tradition, but
     1533 *  there are exceptions. <code>Numeric</code> types, for example,
     1534 *  perform type conversion across <code>==</code>, but not across
     1535 *  <code>eql?</code>, so:
     1536 *
     1537 *     1 == 1.0     #=> true
     1538 *     1.eql? 1.0   #=> false
    14751539 */
    1476 static mrb_value
    1477 mrb_bob_missing(mrb_state *mrb, mrb_value mod)
    1478 {
    1479   mrb_sym name;
    1480   mrb_value *a;
    1481   mrb_int alen;
    1482 
    1483   mrb_get_args(mrb, "n*", &name, &a, &alen);
    1484   mrb_method_missing(mrb, name, mod, mrb_ary_new_from_values(mrb, alen, a));
    1485   /* not reached */
    1486   return mrb_nil_value();
     1540mrb_value
     1541mrb_obj_equal_m(mrb_state *mrb, mrb_value self)
     1542{
     1543  mrb_value arg;
     1544
     1545  mrb_get_args(mrb, "o", &arg);
     1546  return mrb_bool_value(mrb_obj_equal(mrb, self, arg));
     1547}
     1548
     1549static mrb_value
     1550mrb_obj_not_equal_m(mrb_state *mrb, mrb_value self)
     1551{
     1552  mrb_value arg;
     1553
     1554  mrb_get_args(mrb, "o", &arg);
     1555  return mrb_bool_value(!mrb_equal(mrb, self, arg));
    14871556}
    14881557
    … …  
    15331602      return mrb_nil_value();
    15341603    }
    1535     else if (outer && outer != mrb->object_class) {
     1604    else if (outer && outer != c && outer != mrb->object_class) {
    15361605      mrb_value base = mrb_class_path(mrb, outer);
    15371606      path = mrb_str_buf_new(mrb, 0);
    … …  
    15521621      path = mrb_str_new(mrb, name, len);
    15531622    }
    1554     mrb_obj_iv_set(mrb, (struct RObject*)c, classpath, path);
    1555   }
    1556   return path;
     1623    if (!MRB_FROZEN_P(c)) {
     1624      mrb_obj_iv_set(mrb, (struct RObject*)c, classpath, path);
     1625    }
     1626  }
     1627  return mrb_str_dup(mrb, path);
    15571628}
    15581629
    … …  
    16991770    str = mrb_str_new_lit(mrb, "#<Class:");
    17001771
    1701     switch (mrb_type(v)) {
    1702       case MRB_TT_CLASS:
    1703       case MRB_TT_MODULE:
    1704       case MRB_TT_SCLASS:
    1705         mrb_str_cat_str(mrb, str, mrb_inspect(mrb, v));
    1706         break;
    1707       default:
    1708         mrb_str_cat_str(mrb, str, mrb_any_to_s(mrb, v));
    1709         break;
     1772    if (class_ptr_p(v)) {
     1773      mrb_str_cat_str(mrb, str, mrb_inspect(mrb, v));
     1774    }
     1775    else {
     1776      mrb_str_cat_str(mrb, str, mrb_any_to_s(mrb, v));
    17101777    }
    17111778    return mrb_str_cat_lit(mrb, str, ">");
    … …  
    17861853  mrb_get_args(mrb, "*", &argv, &argc);
    17871854  while (argc--) {
    1788     undef_method(mrb, c, mrb_symbol(*argv));
     1855    undef_method(mrb, c, to_sym(mrb, *argv));
    17891856    argv++;
    17901857  }
    … …  
    17981865  struct RProc *p;
    17991866  mrb_sym mid;
     1867  mrb_value proc = mrb_undef_value();
    18001868  mrb_value blk;
    18011869
    1802   mrb_get_args(mrb, "n&", &mid, &blk);
     1870  mrb_get_args(mrb, "n|o&", &mid, &proc, &blk);
     1871  switch (mrb_type(proc)) {
     1872    case MRB_TT_PROC:
     1873      blk = proc;
     1874      break;
     1875    case MRB_TT_UNDEF:
     1876      /* ignored */
     1877      break;
     1878    default:
     1879      mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %S (expected Proc)", mrb_obj_value(mrb_obj_class(mrb, proc)));
     1880      break;
     1881  }
    18031882  if (mrb_nil_p(blk)) {
    18041883    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
    … …  
    20282107  mrb_get_args(mrb, "*", &argv, &argc);
    20292108  while (argc--) {
    2030     remove_method(mrb, mod, mrb_symbol(*argv));
     2109    remove_method(mrb, mod, to_sym(mrb, *argv));
    20312110    argv++;
    20322111  }
    … …  
    21592238
    21602239  mrb_get_args(mrb, "*", &argv, &argc);
    2161   if(argc == 0) {
     2240  if (argc == 0) {
    21622241    /* set MODFUNC SCOPE if implemented */
    21632242    return mod;
    … …  
    21822261  return mod;
    21832262}
     2263
     2264/* implementation of __id__ */
     2265mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self);
     2266/* implementation of instance_eval */
     2267mrb_value mrb_obj_instance_eval(mrb_state*, mrb_value);
    21842268
    21852269void
    … …  
    22222306  mrb_define_method(mrb, bob, "initialize",              mrb_bob_init,             MRB_ARGS_NONE());
    22232307  mrb_define_method(mrb, bob, "!",                       mrb_bob_not,              MRB_ARGS_NONE());
    2224   mrb_define_method(mrb, bob, "method_missing",          mrb_bob_missing,          MRB_ARGS_ANY());  /* 15.3.1.3.30 */
     2308  mrb_define_method(mrb, bob, "==",                      mrb_obj_equal_m,          MRB_ARGS_REQ(1)); /* 15.3.1.3.1  */
     2309  mrb_define_method(mrb, bob, "!=",                      mrb_obj_not_equal_m,      MRB_ARGS_REQ(1));
     2310  mrb_define_method(mrb, bob, "__id__",                  mrb_obj_id_m,             MRB_ARGS_NONE()); /* 15.3.1.3.3  */
     2311  mrb_define_method(mrb, bob, "__send__",                mrb_f_send,               MRB_ARGS_ANY());  /* 15.3.1.3.4  */
     2312  mrb_define_method(mrb, bob, "instance_eval",           mrb_obj_instance_eval,    MRB_ARGS_ANY());  /* 15.3.1.3.18 */
    22252313
    22262314  mrb_define_class_method(mrb, cls, "new",               mrb_class_new_class,      MRB_ARGS_OPT(1));
    … …  
    22362324  mrb_define_method(mrb, mod, "extend_object",           mrb_mod_extend_object,    MRB_ARGS_REQ(1)); /* 15.2.2.4.25 */
    22372325  mrb_define_method(mrb, mod, "extended",                mrb_bob_init,             MRB_ARGS_REQ(1)); /* 15.2.2.4.26 */
    2238   mrb_define_method(mrb, mod, "prepend",                 mrb_mod_prepend,          MRB_ARGS_ANY());
    22392326  mrb_define_method(mrb, mod, "prepended",               mrb_bob_init,             MRB_ARGS_REQ(1));
    22402327  mrb_define_method(mrb, mod, "prepend_features",        mrb_mod_prepend_features, MRB_ARGS_REQ(1));
    2241   mrb_define_method(mrb, mod, "include",                 mrb_mod_include,          MRB_ARGS_ANY());  /* 15.2.2.4.27 */
    22422328  mrb_define_method(mrb, mod, "include?",                mrb_mod_include_p,        MRB_ARGS_REQ(1)); /* 15.2.2.4.28 */
    22432329  mrb_define_method(mrb, mod, "append_features",         mrb_mod_append_features,  MRB_ARGS_REQ(1)); /* 15.2.2.4.10 */
    … …  
    22692355  mrb_define_method(mrb, mod, "remove_const",            mrb_mod_remove_const,     MRB_ARGS_REQ(1)); /* 15.2.2.4.40 */
    22702356  mrb_define_method(mrb, mod, "const_missing",           mrb_mod_const_missing,    MRB_ARGS_REQ(1));
    2271   mrb_define_method(mrb, mod, "define_method",           mod_define_method,        MRB_ARGS_REQ(1));
     2357  mrb_define_method(mrb, mod, "define_method",           mod_define_method,        MRB_ARGS_ARG(1,1));
    22722358  mrb_define_method(mrb, mod, "class_variables",         mrb_mod_class_variables,  MRB_ARGS_NONE()); /* 15.2.2.4.19 */
    22732359  mrb_define_method(mrb, mod, "===",                     mrb_mod_eqq,              MRB_ARGS_REQ(1));

  • EcnlProtoTool/trunk/mruby-1.3.0/src/codedump.c

    r321 r331  
    1 #include "mruby.h"
    2 #include "mruby/irep.h"
    3 #include "mruby/debug.h"
    4 #include "mruby/opcode.h"
    5 #include "mruby/string.h"
    6 #include "mruby/proc.h"
     1#include <mruby.h>
     2#include <mruby/irep.h>
     3#include <mruby/debug.h>
     4#include <mruby/opcode.h>
     5#include <mruby/string.h>
     6#include <mruby/proc.h>
    77
    88#ifndef MRB_DISABLE_STDIO
    … …  
    240240      switch (GETARG_B(c)) {
    241241      case OP_R_NORMAL:
     242        printf("\tnormal\t"); break;
    242243      case OP_R_RETURN:
    243244        printf("\treturn\t"); break;
    … …  
    246247      default:
    247248        printf("\tbroken\t"); break;
    248         break;
    249249      }
    250250      print_lv(mrb, irep, c, RA);
    … …  
    260260
    261261    case OP_LAMBDA:
    262       printf("OP_LAMBDA\tR%d\tI(%+d)\t%d", GETARG_A(c), GETARG_b(c)+1, GETARG_c(c));
     262      printf("OP_LAMBDA\tR%d\tI(%+d)\t", GETARG_A(c), GETARG_b(c)+1);
     263      switch (GETARG_c(c)) {
     264      case OP_L_METHOD:
     265        printf("method"); break;
     266      case OP_L_BLOCK:
     267        printf("block"); break;
     268      case OP_L_LAMBDA:
     269        printf("lambda"); break;
     270      }
    263271      print_lv(mrb, irep, c, RA);
    264272      break;
    … …  
    324332      break;
    325333    case OP_EQ:
    326       printf("OP_EQ\tR%d\t:%s\t%d\n", GETARG_A(c),
     334      printf("OP_EQ\t\tR%d\t:%s\t%d\n", GETARG_A(c),
    327335             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    328336             GETARG_C(c));
    … …  
    410418      break;
    411419    case OP_RESCUE:
    412       printf("OP_RESCUE\tR%d\t\t", GETARG_A(c));
    413       print_lv(mrb, irep, c, RA);
     420      {
     421        int a = GETARG_A(c);
     422        int b = GETARG_B(c);
     423        int cnt = GETARG_C(c);
     424
     425        if (b == 0) {
     426          printf("OP_RESCUE\tR%d\t\t%s", a, cnt ? "cont" : "");
     427          print_lv(mrb, irep, c, RA);
     428          break;
     429        }
     430        else {
     431          printf("OP_RESCUE\tR%d\tR%d\t%s", a, b, cnt ? "cont" : "");
     432          print_lv(mrb, irep, c, RAB);
     433          break;
     434        }
     435      }
    414436      break;
    415437    case OP_RAISE:
    … …  
    418440      break;
    419441    case OP_POPERR:
    420       printf("OP_POPERR\t%d\t\t", GETARG_A(c));
    421       print_lv(mrb, irep, c, RA);
     442      printf("OP_POPERR\t%d\t\t\n", GETARG_A(c));
    422443      break;
    423444    case OP_EPOP:

  • EcnlProtoTool/trunk/mruby-1.3.0/src/compar.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
     7#include <mruby.h>
    88
    99void

  • EcnlProtoTool/trunk/mruby-1.3.0/src/debug.c

    r321 r331  
    11#include <string.h>
    2 #include "mruby.h"
    3 #include "mruby/irep.h"
    4 #include "mruby/debug.h"
     2#include <mruby.h>
     3#include <mruby/irep.h>
     4#include <mruby/debug.h>
    55
    66static mrb_irep_debug_info_file *
    … …  
    2020      ret = it + 1;
    2121      count -= step + 1;
    22     } else { count = step; }
     22    }
     23    else { count = step; }
    2324  }
    2425
    … …  
    8788              ret = it + 1;
    8889              count -= step + 1;
    89             } else { count = step; }
     90            }
     91            else { count = step; }
    9092          }
    9193

  • EcnlProtoTool/trunk/mruby-1.3.0/src/dump.c

    r321 r331  
    77#include <string.h>
    88#include <limits.h>
    9 #include "mruby/dump.h"
    10 #include "mruby/string.h"
    11 #include "mruby/irep.h"
    12 #include "mruby/numeric.h"
    13 #include "mruby/debug.h"
     9#include <mruby/dump.h>
     10#include <mruby/string.h>
     11#include <mruby/irep.h>
     12#include <mruby/numeric.h>
     13#include <mruby/debug.h>
    1414
    1515#define FLAG_BYTEORDER_NATIVE 2
    … …  
    5555  uint8_t *cur = buf;
    5656
    57   cur += uint32_to_bin(get_irep_record_size_1(mrb, irep), cur);  /* record size */
     57  cur += uint32_to_bin((uint32_t)get_irep_record_size_1(mrb, irep), cur);  /* record size */
    5858  cur += uint16_to_bin((uint16_t)irep->nlocals, cur);  /* number of local variable */
    5959  cur += uint16_to_bin((uint16_t)irep->nregs, cur);  /* number of register variable */
    … …  
    408408  if (irep->filename) {
    409409    filename_len = strlen(irep->filename);
    410   } else {
     410  }
     411  else {
    411412    filename_len = 0;
    412413  }
    … …  
    10601061    }
    10611062    if (fprintf(fp,
     1063          "extern const uint8_t %s[];\n"
    10621064          "const uint8_t\n"
    10631065          "#if defined __GNUC__\n"
    … …  
    10671069          "#endif\n"
    10681070          "%s[] = {",
     1071          initname,
    10691072          (uint16_t)MRB_DUMP_ALIGNMENT, (uint16_t)MRB_DUMP_ALIGNMENT, initname) < 0) {
    10701073      mrb_free(mrb, bin);

  • EcnlProtoTool/trunk/mruby-1.3.0/src/enum.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
     7#include <mruby.h>
    88
    99void

  • EcnlProtoTool/trunk/mruby-1.3.0/src/error.c

    r321 r331  
    88#include <stdarg.h>
    99#include <stdlib.h>
    10 #include "mruby.h"
    11 #include "mruby/array.h"
    12 #include "mruby/irep.h"
    13 #include "mruby/proc.h"
    14 #include "mruby/string.h"
    15 #include "mruby/variable.h"
    16 #include "mruby/debug.h"
    17 #include "mruby/error.h"
    18 #include "mruby/class.h"
    19 #include "mruby/throw.h"
     10#include <mruby.h>
     11#include <mruby/array.h>
     12#include <mruby/irep.h>
     13#include <mruby/proc.h>
     14#include <mruby/string.h>
     15#include <mruby/variable.h>
     16#include <mruby/debug.h>
     17#include <mruby/error.h>
     18#include <mruby/class.h>
     19#include <mruby/throw.h>
    2020
    2121MRB_API mrb_value
    … …  
    4545{
    4646  mrb_value mesg;
    47 
    48   if (mrb_get_args(mrb, "|o", &mesg) == 1) {
     47  mrb_int argc;
     48  mrb_value *argv;
     49
     50  if (mrb_get_args(mrb, "|o*", &mesg, &argv, &argc) >= 1) {
    4951    mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), mesg);
    5052  }
    … …  
    6163 *  return the receiver. Otherwise, create a new
    6264 *  exception object of the same class as the receiver, but with a
    63  *  message equal to <code>string.to_str</code>.
     65 *  message equal to <code>string</code>.
    6466 *
    6567 */
    … …  
    110112 *
    111113 * Returns the result of invoking <code>exception.to_s</code>.
    112  * Normally this returns the exception's message or name. By
    113  * supplying a to_str method, exceptions are agreeing to
    114  * be used where Strings are expected.
     114 * Normally this returns the exception's message or name.
    115115 */
    116116
    … …  
    136136  mrb_value str, mesg, file, line;
    137137  mrb_bool append_mesg;
     138  const char *cname;
    138139
    139140  mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
    … …  
    147148  }
    148149
    149   if (!mrb_nil_p(file) && !mrb_nil_p(line)) {
    150     str = mrb_str_dup(mrb, file);
    151     mrb_str_cat_lit(mrb, str, ":");
    152     mrb_str_append(mrb, str, line);
    153     mrb_str_cat_lit(mrb, str, ": ");
     150  cname = mrb_obj_classname(mrb, exc);
     151  str = mrb_str_new_cstr(mrb, cname);
     152  if (mrb_string_p(file) && mrb_fixnum_p(line)) {
    154153    if (append_mesg) {
    155       mrb_str_cat_str(mrb, str, mesg);
    156       mrb_str_cat_lit(mrb, str, " (");
    157     }
    158     mrb_str_cat_cstr(mrb, str, mrb_obj_classname(mrb, exc));
    159     if (append_mesg) {
    160       mrb_str_cat_lit(mrb, str, ")");
    161     }
     154      str = mrb_format(mrb, "%S:%S:%S (%S)", file, line, mesg, str);
     155    }
     156    else {
     157      str = mrb_format(mrb, "%S:%S:%S", file, line, str);
     158    }
     159  }
     160  else if (append_mesg) {
     161    str = mrb_format(mrb, "%S:%S", str, mesg);
     162  }
     163  return str;
     164}
     165
     166void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc);
     167
     168static void
     169set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace)
     170{
     171  if (!mrb_array_p(backtrace)) {
     172  type_err:
     173    mrb_raise(mrb, E_TYPE_ERROR, "backtrace must be Array of String");
    162174  }
    163175  else {
    164     const char *cname = mrb_obj_classname(mrb, exc);
    165     str = mrb_str_new_cstr(mrb, cname);
    166     mrb_str_cat_lit(mrb, str, ": ");
    167     if (append_mesg) {
    168       mrb_str_cat_str(mrb, str, mesg);
    169     }
    170     else {
    171       mrb_str_cat_cstr(mrb, str, cname);
    172     }
    173   }
    174   return str;
    175 }
    176 
     176    const mrb_value *p = RARRAY_PTR(backtrace);
     177    const mrb_value *pend = p + RARRAY_LEN(backtrace);
     178
     179    while (p < pend) {
     180      if (!mrb_string_p(*p)) goto type_err;
     181      p++;
     182    }
     183  }
     184  mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "backtrace"), backtrace);
     185}
     186
     187static mrb_value
     188exc_set_backtrace(mrb_state *mrb, mrb_value exc)
     189{
     190  mrb_value backtrace;
     191
     192  mrb_get_args(mrb, "o", &backtrace);
     193  set_backtrace(mrb, exc, backtrace);
     194  return backtrace;
     195}
    177196
    178197static void
    … …  
    182201  mrb_code *pc = ci->pc;
    183202
    184   mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "ciidx"), mrb_fixnum_value((mrb_int)(ci - mrb->c->cibase)));
    185203  while (ci >= mrb->c->cibase) {
    186204    mrb_code *err = ci->err;
    … …  
    203221}
    204222
     223void
     224mrb_exc_set(mrb_state *mrb, mrb_value exc)
     225{
     226  if (mrb_nil_p(exc)) {
     227    mrb->exc = 0;
     228  }
     229  else {
     230    mrb->exc = mrb_obj_ptr(exc);
     231    if (!mrb->gc.out_of_memory) {
     232      exc_debug_info(mrb, mrb->exc);
     233      mrb_keep_backtrace(mrb, exc);
     234    }
     235  }
     236}
     237
    205238MRB_API mrb_noreturn void
    206239mrb_exc_raise(mrb_state *mrb, mrb_value exc)
    207240{
    208   mrb->exc = mrb_obj_ptr(exc);
    209   if (!mrb->gc.out_of_memory) {
    210     exc_debug_info(mrb, mrb->exc);
    211   }
     241  if (!mrb_obj_is_kind_of(mrb, exc, mrb->eException_class)) {
     242    mrb_raise(mrb, E_TYPE_ERROR, "exception object expected");
     243  }
     244  mrb_exc_set(mrb, exc);
    212245  if (!mrb->jmp) {
    213246    mrb_p(mrb, exc);
    … …  
    220253mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
    221254{
    222   mrb_value mesg;
    223   mesg = mrb_str_new_cstr(mrb, msg);
    224   mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg));
     255  mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mrb_str_new_cstr(mrb, msg)));
    225256}
    226257
    … …  
    232263  ptrdiff_t size;
    233264  mrb_value ary = mrb_ary_new_capa(mrb, 4);
     265  int ai = mrb_gc_arena_save(mrb);
    234266
    235267  while (*p) {
    … …  
    255287      }
    256288    }
     289    mrb_gc_arena_restore(mrb, ai);
    257290  }
    258291  if (b == format) {
    … …  
    261294  else {
    262295    size = p - b;
    263     mrb_ary_push(mrb, ary, mrb_str_new(mrb, b, size));
    264     return mrb_ary_join(mrb, ary, mrb_str_new(mrb, NULL, 0));
     296    if (size > 0) {
     297      mrb_ary_push(mrb, ary, mrb_str_new(mrb, b, size));
     298      mrb_gc_arena_restore(mrb, ai);
     299    }
     300    return mrb_ary_join(mrb, ary, mrb_nil_value());
    265301  }
    266302}
    … …  
    279315}
    280316
     317static mrb_noreturn void
     318raise_va(mrb_state *mrb, struct RClass *c, const char *fmt, va_list ap, int argc, mrb_value *argv)
     319{
     320  mrb_value mesg;
     321
     322  mesg = mrb_vformat(mrb, fmt, ap);
     323  if (argv == NULL) {
     324    argv = &mesg;
     325  }
     326  else {
     327    argv[0] = mesg;
     328  }
     329  mrb_exc_raise(mrb, mrb_obj_new(mrb, c, argc+1, argv));
     330}
     331
    281332MRB_API mrb_noreturn void
    282333mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
    283334{
    284335  va_list args;
    285   mrb_value mesg;
    286336
    287337  va_start(args, fmt);
    288   mesg = mrb_vformat(mrb, fmt, args);
     338  raise_va(mrb, c, fmt, args, 0, NULL);
    289339  va_end(args);
    290   mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mesg));
    291340}
    292341
    … …  
    294343mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
    295344{
    296   mrb_value exc;
    297345  mrb_value argv[2];
    298346  va_list args;
    299347
    300348  va_start(args, fmt);
    301   argv[0] = mrb_vformat(mrb, fmt, args);
     349  argv[1] = mrb_symbol_value(id);
     350  raise_va(mrb, E_NAME_ERROR, fmt, args, 1, argv);
    302351  va_end(args);
    303 
    304   argv[1] = mrb_symbol_value(id);
    305   exc = mrb_obj_new(mrb, E_NAME_ERROR, 2, argv);
    306   mrb_exc_raise(mrb, exc);
    307352}
    308353
    … …  
    338383}
    339384
    340 static void
    341 set_backtrace(mrb_state *mrb, mrb_value info, mrb_value bt)
    342 {
    343   mrb_funcall(mrb, info, "set_backtrace", 1, bt);
    344 }
    345 
    346 static mrb_value
    347 make_exception(mrb_state *mrb, int argc, const mrb_value *argv, mrb_bool isstr)
     385MRB_API mrb_value
     386mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv)
    348387{
    349388  mrb_value mesg;
    … …  
    357396      if (mrb_nil_p(argv[0]))
    358397        break;
    359       if (isstr) {
    360         mesg = mrb_check_string_type(mrb, argv[0]);
    361         if (!mrb_nil_p(mesg)) {
    362           mesg = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, mesg);
    363           break;
    364         }
     398      if (mrb_string_p(argv[0])) {
     399        mesg = mrb_exc_new_str(mrb, E_RUNTIME_ERROR, argv[0]);
     400        break;
    365401      }
    366402      n = 0;
    … …  
    389425  if (argc > 0) {
    390426    if (!mrb_obj_is_kind_of(mrb, mesg, mrb->eException_class))
    391       mrb_raise(mrb, E_TYPE_ERROR, "exception object expected");
     427      mrb_raise(mrb, mrb->eException_class, "exception object expected");
    392428    if (argc > 2)
    393         set_backtrace(mrb, mesg, argv[2]);
     429      set_backtrace(mrb, mesg, argv[2]);
    394430  }
    395431
    396432  return mesg;
    397 }
    398 
    399 MRB_API mrb_value
    400 mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv)
    401 {
    402   return make_exception(mrb, argc, argv, TRUE);
    403433}
    404434
    … …  
    428458{
    429459  mrb_value exc;
     460  mrb_value argv[3];
    430461  va_list ap;
    431462
    432463  va_start(ap, fmt);
    433   exc = mrb_funcall(mrb, mrb_obj_value(E_NOMETHOD_ERROR), "new", 3,
    434                     mrb_vformat(mrb, fmt, ap), mrb_symbol_value(id), args);
     464  argv[0] = mrb_vformat(mrb, fmt, ap);
     465  argv[1] = mrb_symbol_value(id);
     466  argv[2] = args;
    435467  va_end(ap);
     468  exc = mrb_obj_new(mrb, E_NOMETHOD_ERROR, 3, argv);
    436469  mrb_exc_raise(mrb, exc);
    437470}
    … …  
    440473mrb_init_exception(mrb_state *mrb)
    441474{
    442   struct RClass *exception, *runtime_error, *script_error;
     475  struct RClass *exception, *script_error, *stack_error, *nomem_error;
    443476
    444477  mrb->eException_class = exception = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */
    … …  
    451484  mrb_define_method(mrb, exception, "inspect",         exc_inspect,       MRB_ARGS_NONE());
    452485  mrb_define_method(mrb, exception, "backtrace",       mrb_exc_backtrace, MRB_ARGS_NONE());
     486  mrb_define_method(mrb, exception, "set_backtrace",   exc_set_backtrace, MRB_ARGS_REQ(1));
    453487
    454488  mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */
    455   runtime_error = mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class);          /* 15.2.28 */
    456   mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, runtime_error, "Out of memory"));
     489  mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class);          /* 15.2.28 */
    457490  script_error = mrb_define_class(mrb, "ScriptError", mrb->eException_class);                /* 15.2.37 */
    458491  mrb_define_class(mrb, "SyntaxError", script_error);                                        /* 15.2.38 */
    459   mrb_define_class(mrb, "SystemStackError", exception);
    460 }
     492  stack_error = mrb_define_class(mrb, "SystemStackError", exception);
     493  mrb->stack_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, stack_error, "stack level too deep"));
     494
     495  nomem_error = mrb_define_class(mrb, "NoMemoryError", exception);
     496  mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "Out of memory"));
     497#ifdef MRB_GC_FIXED_ARENA
     498  mrb->arena_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "arena overflow error"));
     499#endif
     500}

  • EcnlProtoTool/trunk/mruby-1.3.0/src/error.h

    r321 r331  
    11/* this header file is to be removed soon.
    22   added for compatibility purpose (1.0.0) */
    3 #include "mruby/error.h"
     3#include <mruby/error.h>

  • EcnlProtoTool/trunk/mruby-1.3.0/src/etc.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/string.h"
    9 #include "mruby/data.h"
    10 #include "mruby/class.h"
    11 #include "mruby/re.h"
    12 #include "mruby/irep.h"
     7#include <mruby.h>
     8#include <mruby/string.h>
     9#include <mruby/data.h>
     10#include <mruby/class.h>
     11#include <mruby/re.h>
     12#include <mruby/irep.h>
    1313
    1414MRB_API struct RData*
    … …  
    140140  case MRB_TT_FILE:
    141141  case MRB_TT_DATA:
     142  case MRB_TT_ISTRUCT:
    142143  default:
    143144    return MakeID(mrb_ptr(obj));
    … …  
    180181mrb_regexp_p(mrb_state *mrb, mrb_value v)
    181182{
    182   return mrb_class_defined(mrb, REGEXP_CLASS) && mrb_obj_is_kind_of(mrb, v, mrb_class_get(mrb, REGEXP_CLASS));
     183  if (mrb->flags & MRB_STATE_NO_REGEXP) {
     184    return FALSE;
     185  }
     186  if ((mrb->flags & MRB_STATE_REGEXP) || mrb_class_defined(mrb, REGEXP_CLASS)) {
     187    mrb->flags |= MRB_STATE_REGEXP;
     188    return mrb_obj_is_kind_of(mrb, v, mrb_class_get(mrb, REGEXP_CLASS));
     189  }
     190  else {
     191    mrb->flags |= MRB_STATE_REGEXP;
     192    mrb->flags |= MRB_STATE_NO_REGEXP;
     193  }
     194  return FALSE;
    183195}
    184196

  • EcnlProtoTool/trunk/mruby-1.3.0/src/fmt_fp.c

    r321 r331  
    3434#include <ctype.h>
    3535
    36 #include "mruby.h"
    37 #include "mruby/string.h"
     36#include <mruby.h>
     37#include <mruby/string.h>
    3838
    3939struct fmt_args {
    … …  
    157157    s=buf;
    158158    do {
    159       int x=y;
     159      int x=(int)y;
    160160      *s++=xdigits[x]|(t&32);
    161161      y=16*(y-x);
    … …  
    185185
    186186  do {
    187     *z = y;
     187    *z = (uint32_t)y;
    188188    y = 1000000000*(y-*z++);
    189189  } while (y);
    … …  
    195195      uint64_t x = ((uint64_t)*d<<sh)+carry;
    196196      *d = x % 1000000000;
    197       carry = x / 1000000000;
     197      carry = (uint32_t)(x / 1000000000);
    198198    }
    199199    if (carry) *--a = carry;
    … …  
    254254  }
    255255  for (; z>a && !z[-1]; z--);
    256  
     256
    257257  if ((t|32)=='g') {
    258258    if (!p) p++;
    … …  
    355355  default:
    356356    return -1;
    357   } 
     357  }
    358358}
    359359

  • EcnlProtoTool/trunk/mruby-1.3.0/src/gc.c

    r321 r331  
    77#include <string.h>
    88#include <stdlib.h>
    9 #include "mruby.h"
    10 #include "mruby/array.h"
    11 #include "mruby/class.h"
    12 #include "mruby/data.h"
    13 #include "mruby/hash.h"
    14 #include "mruby/proc.h"
    15 #include "mruby/range.h"
    16 #include "mruby/string.h"
    17 #include "mruby/variable.h"
    18 #include "mruby/gc.h"
    19 #include "mruby/error.h"
     9#include <mruby.h>
     10#include <mruby/array.h>
     11#include <mruby/class.h>
     12#include <mruby/data.h>
     13#include <mruby/hash.h>
     14#include <mruby/proc.h>
     15#include <mruby/range.h>
     16#include <mruby/string.h>
     17#include <mruby/variable.h>
     18#include <mruby/gc.h>
     19#include <mruby/error.h>
     20#include <mruby/throw.h>
    2021
    2122/*
    … …  
    6667  mruby implementer and C extension library writer must insert a write
    6768  barrier when updating a reference from a field of an object.
    68   When updating a reference from a field of object A to object B, 
     69  When updating a reference from a field of object A to object B,
    6970  two different types of write barrier are available:
    7071
    … …  
    110111    struct RData data;
    111112    struct RProc proc;
     113    struct REnv env;
    112114    struct RException exc;
     115    struct RBreak brk;
    113116#ifdef MRB_WORD_BOXING
    114117    struct RFloat floatv;
    … …  
    138141  fprintf(stderr, "gc_invoke: %19.3f\n", gettimeofday_time() - program_invoke_time);\
    139142  fprintf(stderr, "is_generational: %d\n", is_generational(gc));\
    140   fprintf(stderr, "is_major_gc: %d\n", is_major_gc(mrb));\
     143  fprintf(stderr, "is_major_gc: %d\n", is_major_gc(gc));\
    141144} while(0)
    142145
    … …  
    214217
    215218  p2 = mrb_realloc_simple(mrb, p, len);
    216   if (!p2 && len) {
     219  if (len == 0) return p2;
     220  if (p2 == NULL) {
    217221    if (mrb->gc.out_of_memory) {
     222      mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
    218223      /* mrb_panic(mrb); */
    219224    }
    … …  
    367372}
    368373
    369 static void obj_free(mrb_state *mrb, struct RBasic *obj);
     374static void obj_free(mrb_state *mrb, struct RBasic *obj, int end);
    370375
    371376void
    … …  
    381386    for (p = objects(tmp), e=p+MRB_HEAP_PAGE_SIZE; p<e; p++) {
    382387      if (p->as.free.tt != MRB_TT_FREE)
    383         obj_free(mrb, &p->as.basic);
     388        obj_free(mrb, &p->as.basic, TRUE);
    384389    }
    385390    mrb_free(mrb, tmp);
    … …  
    403408    /* arena overflow error */
    404409    gc->arena_idx = MRB_GC_ARENA_SIZE - 4; /* force room in arena */
    405     mrb_raise(mrb, E_RUNTIME_ERROR, "arena overflow error");
     410    mrb_exc_raise(mrb, mrb_obj_value(mrb->arena_err));
    406411  }
    407412#else
    … …  
    429434   Register your object when it's exported to C world,
    430435   without reference from Ruby world, e.g. callback
    431    arguments.  Don't forget to remove the obejct using
     436   arguments.  Don't forget to remove the object using
    432437   mrb_gc_unregister, otherwise your object will leak.
    433438*/
    … …  
    453458  mrb_value table = mrb_gv_get(mrb, root);
    454459  struct RArray *a;
    455   mrb_int i, j;
     460  mrb_int i;
    456461
    457462  if (mrb_nil_p(table)) return;
    … …  
    462467  a = mrb_ary_ptr(table);
    463468  mrb_ary_modify(mrb, a);
    464   for (i=j=0; i<a->len; i++) {
    465     if (!mrb_obj_eq(mrb, a->ptr[i], obj)) {
    466       a->ptr[j++] = a->ptr[i];
    467     }
    468   }
    469   a->len = j;
     469  for (i = 0; i < a->len; i++) {
     470    if (mrb_obj_eq(mrb, a->ptr[i], obj)) {
     471      a->len--;
     472      memmove(&a->ptr[i], &a->ptr[i + 1], (a->len - i) * sizeof(a->ptr[i]));
     473      break;
     474    }
     475  }
    470476}
    471477
    … …  
    476482  static const RVALUE RVALUE_zero = { { { MRB_TT_FALSE } } };
    477483  mrb_gc *gc = &mrb->gc;
     484
     485  if (cls) {
     486    enum mrb_vtype tt;
     487
     488    switch (cls->tt) {
     489    case MRB_TT_CLASS:
     490    case MRB_TT_SCLASS:
     491    case MRB_TT_MODULE:
     492    case MRB_TT_ENV:
     493      break;
     494    default:
     495      mrb_raise(mrb, E_TYPE_ERROR, "allocation failure");
     496    }
     497    tt = MRB_INSTANCE_TT(cls);
     498    if (tt != MRB_TT_FALSE &&
     499        ttype != MRB_TT_SCLASS &&
     500        ttype != MRB_TT_ICLASS &&
     501        ttype != MRB_TT_ENV &&
     502        ttype != tt) {
     503      mrb_raisef(mrb, E_TYPE_ERROR, "allocation failure of %S", mrb_obj_value(cls));
     504    }
     505  }
    478506
    479507#ifdef MRB_GC_STRESS
    … …  
    520548  size_t i;
    521549  size_t e;
    522 
     550  mrb_value nil;
     551  int nregs;
     552
     553  if (c->stack == NULL) return;
    523554  e = c->stack - c->stbase;
    524   if (c->ci) e += c->ci->nregs;
     555  if (c->ci) {
     556    nregs = c->ci->argc + 2;
     557    if (c->ci->nregs > nregs)
     558      nregs = c->ci->nregs;
     559    e += nregs;
     560  }
    525561  if (c->stbase + e > c->stend) e = c->stend - c->stbase;
    526562  for (i=0; i<e; i++) {
    … …  
    528564
    529565    if (!mrb_immediate_p(v)) {
    530       if (mrb_basic_ptr(v)->tt == MRB_TT_FREE) {
    531         c->stbase[i] = mrb_nil_value();
    532       }
    533       else {
    534         mrb_gc_mark(mrb, mrb_basic_ptr(v));
    535       }
    536     }
     566      mrb_gc_mark(mrb, mrb_basic_ptr(v));
     567    }
     568  }
     569  e = c->stend - c->stbase;
     570  nil = mrb_nil_value();
     571  for (; i<e; i++) {
     572    c->stbase[i] = nil;
    537573  }
    538574}
    … …  
    541577mark_context(mrb_state *mrb, struct mrb_context *c)
    542578{
    543   int i, e = 0;
     579  int i;
    544580  mrb_callinfo *ci;
    545581
    546   /* mark stack */
     582  /* mark VM stack */
    547583  mark_context_stack(mrb, c);
    548584
    549   /* mark VM stack */
     585  /* mark call stack */
    550586  if (c->cibase) {
    551587    for (ci = c->cibase; ci <= c->ci; ci++) {
    552       if (ci->eidx > e) {
    553         e = ci->eidx;
    554       }
    555588      mrb_gc_mark(mrb, (struct RBasic*)ci->env);
    556589      mrb_gc_mark(mrb, (struct RBasic*)ci->proc);
    … …  
    559592  }
    560593  /* mark ensure stack */
    561   for (i=0; i<e; i++) {
     594  for (i=0; i<c->esize; i++) {
     595    if (c->ensure[i] == NULL) break;
    562596    mrb_gc_mark(mrb, (struct RBasic*)c->ensure[i]);
    563597  }
    564598  /* mark fibers */
    565   if (c->prev && c->prev->fib) {
    566     mrb_gc_mark(mrb, (struct RBasic*)c->prev->fib);
     599  mrb_gc_mark(mrb, (struct RBasic*)c->fib);
     600  if (c->prev) {
     601    mark_context(mrb, c->prev);
    567602  }
    568603}
    … …  
    614649    {
    615650      struct REnv *e = (struct REnv*)obj;
    616 
    617       if (!MRB_ENV_STACK_SHARED_P(e)) {
    618         mrb_int i, len;
    619 
    620         len = MRB_ENV_STACK_LEN(e);
    621         for (i=0; i<len; i++) {
    622           mrb_gc_mark_value(mrb, e->stack[i]);
     651      mrb_int i, len;
     652
     653      if (MRB_ENV_STACK_SHARED_P(e)) {
     654        if (e->cxt.c->fib) {
     655          mrb_gc_mark(mrb, (struct RBasic*)e->cxt.c->fib);
    623656        }
     657        break;
     658      }
     659      len = MRB_ENV_STACK_LEN(e);
     660      for (i=0; i<len; i++) {
     661        mrb_gc_mark_value(mrb, e->stack[i]);
    624662      }
    625663    }
    … …  
    679717
    680718static void
    681 obj_free(mrb_state *mrb, struct RBasic *obj)
    682 {
    683   DEBUG(printf("obj_free(%p,tt=%d)\n",obj,obj->tt));
     719obj_free(mrb_state *mrb, struct RBasic *obj, int end)
     720{
     721  DEBUG(fprintf(stderr, "obj_free(%p,tt=%d)\n",obj,obj->tt));
    684722  switch (obj->tt) {
    685723    /* immediate - no mark */
    … …  
    698736
    699737  case MRB_TT_OBJECT:
     738    mrb_gc_free_iv(mrb, (struct RObject*)obj);
     739    break;
     740
    700741  case MRB_TT_EXCEPTION:
    701742    mrb_gc_free_iv(mrb, (struct RObject*)obj);
    … …  
    716757      struct REnv *e = (struct REnv*)obj;
    717758
    718       if (!MRB_ENV_STACK_SHARED_P(e)) {
    719         mrb_free(mrb, e->stack);
    720         e->stack = NULL;
     759      if (MRB_ENV_STACK_SHARED_P(e)) {
     760        /* cannot be freed */
     761        return;
    721762      }
     763      mrb_free(mrb, e->stack);
     764      e->stack = NULL;
    722765    }
    723766    break;
    … …  
    727770      struct mrb_context *c = ((struct RFiber*)obj)->cxt;
    728771
    729       if (c != mrb->root_c)
     772      if (!end && c && c != mrb->root_c) {
     773        mrb_callinfo *ci = c->ci;
     774        mrb_callinfo *ce = c->cibase;
     775
     776        while (ce <= ci) {
     777          struct REnv *e = ci->env;
     778          if (e && !is_dead(&mrb->gc, e) &&
     779              e->tt == MRB_TT_ENV && MRB_ENV_STACK_SHARED_P(e)) {
     780            mrb_env_unshare(mrb, e);
     781          }
     782          ci--;
     783        }
    730784        mrb_free_context(mrb, c);
     785      }
    731786    }
    732787    break;
    … …  
    781836root_scan_phase(mrb_state *mrb, mrb_gc *gc)
    782837{
    783   size_t i, e;
     838  int i, e;
    784839
    785840  if (!is_minor_gc(gc)) {
    … …  
    795850  /* mark class hierarchy */
    796851  mrb_gc_mark(mrb, (struct RBasic*)mrb->object_class);
     852
     853  /* mark built-in classes */
     854  mrb_gc_mark(mrb, (struct RBasic*)mrb->class_class);
     855  mrb_gc_mark(mrb, (struct RBasic*)mrb->module_class);
     856  mrb_gc_mark(mrb, (struct RBasic*)mrb->proc_class);
     857  mrb_gc_mark(mrb, (struct RBasic*)mrb->string_class);
     858  mrb_gc_mark(mrb, (struct RBasic*)mrb->array_class);
     859  mrb_gc_mark(mrb, (struct RBasic*)mrb->hash_class);
     860
     861  mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class);
     862  mrb_gc_mark(mrb, (struct RBasic*)mrb->fixnum_class);
     863  mrb_gc_mark(mrb, (struct RBasic*)mrb->true_class);
     864  mrb_gc_mark(mrb, (struct RBasic*)mrb->false_class);
     865  mrb_gc_mark(mrb, (struct RBasic*)mrb->nil_class);
     866  mrb_gc_mark(mrb, (struct RBasic*)mrb->symbol_class);
     867  mrb_gc_mark(mrb, (struct RBasic*)mrb->kernel_module);
     868
     869  mrb_gc_mark(mrb, (struct RBasic*)mrb->eException_class);
     870  mrb_gc_mark(mrb, (struct RBasic*)mrb->eStandardError_class);
     871
    797872  /* mark top_self */
    798873  mrb_gc_mark(mrb, (struct RBasic*)mrb->top_self);
    … …  
    801876  /* mark pre-allocated exception */
    802877  mrb_gc_mark(mrb, (struct RBasic*)mrb->nomem_err);
    803 
    804   mark_context(mrb, mrb->root_c);
    805   if (mrb->root_c->fib) {
    806     mrb_gc_mark(mrb, (struct RBasic*)mrb->root_c->fib);
    807   }
     878  mrb_gc_mark(mrb, (struct RBasic*)mrb->stack_err);
     879#ifdef MRB_GC_FIXED_ARENA
     880  mrb_gc_mark(mrb, (struct RBasic*)mrb->arena_err);
     881#endif
     882
     883  mark_context(mrb, mrb->c);
    808884  if (mrb->root_c != mrb->c) {
    809     mark_context(mrb, mrb->c);
     885    mark_context(mrb, mrb->root_c);
    810886  }
    811887}
    … …  
    859935
    860936      /* mark ensure stack */
    861       children += (c->ci) ? c->ci->eidx : 0;
     937      children += c->eidx;
    862938
    863939      /* mark closure */
    … …  
    920996final_marking_phase(mrb_state *mrb, mrb_gc *gc)
    921997{
    922   mark_context_stack(mrb, mrb->root_c);
     998  int i, e;
     999
     1000  /* mark arena */
     1001  for (i=0,e=gc->arena_idx; i<e; i++) {
     1002    mrb_gc_mark(mrb, gc->arena[i]);
     1003  }
     1004  mrb_gc_mark_gv(mrb);
     1005  mark_context(mrb, mrb->c);
     1006  mark_context(mrb, mrb->root_c);
     1007  mrb_gc_mark(mrb, (struct RBasic*)mrb->exc);
    9231008  gc_mark_gray_list(mrb, gc);
    9241009  mrb_assert(gc->gray_list == NULL);
    … …  
    9581043      if (is_dead(gc, &p->as.basic)) {
    9591044        if (p->as.basic.tt != MRB_TT_FREE) {
    960           obj_free(mrb, &p->as.basic);
    961           p->as.free.next = page->freelist;
    962           page->freelist = (struct RBasic*)p;
    963           freed++;
     1045          obj_free(mrb, &p->as.basic, FALSE);
     1046          if (p->as.basic.tt == MRB_TT_FREE) {
     1047            p->as.free.next = page->freelist;
     1048            page->freelist = (struct RBasic*)p;
     1049            freed++;
     1050          }
     1051          else {
     1052            dead_slot = FALSE;
     1053          }
    9641054        }
    9651055      }
    … …  
    9671057        if (!is_generational(gc))
    9681058          paint_partial_white(gc, &p->as.basic); /* next gc target */
    969         dead_slot = 0;
     1059        dead_slot = FALSE;
    9701060      }
    9711061      p++;
    … …  
    10801170  mrb_gc *gc = &mrb->gc;
    10811171
    1082   if (gc->disabled) return;
     1172  if (gc->disabled || gc->iterating) return;
    10831173
    10841174  GC_INVOKE_TIME_REPORT("mrb_incremental_gc()");
    … …  
    11201210  mrb_gc *gc = &mrb->gc;
    11211211
    1122   if (gc->disabled) return;
     1212  if (gc->disabled || gc->iterating) return;
    11231213
    11241214  GC_INVOKE_TIME_REPORT("mrb_full_gc()");
    … …  
    13571447change_gen_gc_mode(mrb_state *mrb, mrb_gc *gc, mrb_bool enable)
    13581448{
     1449  if (gc->disabled || gc->iterating) {
     1450    mrb_raise(mrb, E_RUNTIME_ERROR, "generational mode changed when GC disabled");
     1451    return;
     1452  }
    13591453  if (is_generational(gc) && !enable) {
    13601454    clear_all_old(mrb, gc);
    … …  
    14081502gc_each_objects(mrb_state *mrb, mrb_gc *gc, mrb_each_object_callback *callback, void *data)
    14091503{
    1410   mrb_heap_page* page = gc->heaps;
    1411 
     1504  mrb_heap_page* page;
     1505
     1506  page = gc->heaps;
    14121507  while (page != NULL) {
    1413     RVALUE *p, *pend;
     1508    RVALUE *p;
     1509    int i;
    14141510
    14151511    p = objects(page);
    1416     pend = p + MRB_HEAP_PAGE_SIZE;
    1417     for (;p < pend; p++) {
    1418       (*callback)(mrb, &p->as.basic, data);
    1419     }
    1420 
     1512    for (i=0; i < MRB_HEAP_PAGE_SIZE; i++) {
     1513      if ((*callback)(mrb, &p[i].as.basic, data) == MRB_EACH_OBJ_BREAK)
     1514        return;
     1515    }
    14211516    page = page->next;
    14221517  }
    … …  
    14261521mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, void *data)
    14271522{
    1428   gc_each_objects(mrb, &mrb->gc, callback, data);
     1523  mrb_bool iterating = mrb->gc.iterating;
     1524
     1525  mrb->gc.iterating = TRUE;
     1526  if (iterating) {
     1527    gc_each_objects(mrb, &mrb->gc, callback, data);
     1528  }
     1529  else {
     1530    struct mrb_jmpbuf *prev_jmp = mrb->jmp;
     1531    struct mrb_jmpbuf c_jmp;
     1532
     1533    MRB_TRY(&c_jmp) {
     1534      mrb->jmp = &c_jmp;
     1535      gc_each_objects(mrb, &mrb->gc, callback, data);
     1536      mrb->jmp = prev_jmp;
     1537      mrb->gc.iterating = iterating;
     1538   } MRB_CATCH(&c_jmp) {
     1539      mrb->gc.iterating = iterating;
     1540      mrb->jmp = prev_jmp;
     1541      MRB_THROW(prev_jmp);
     1542    } MRB_END_EXC(&c_jmp);
     1543  }
    14291544}
    14301545

  • EcnlProtoTool/trunk/mruby-1.3.0/src/hash.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/array.h"
    9 #include "mruby/class.h"
    10 #include "mruby/hash.h"
    11 #include "mruby/khash.h"
    12 #include "mruby/string.h"
    13 #include "mruby/variable.h"
     7#include <mruby.h>
     8#include <mruby/array.h>
     9#include <mruby/class.h>
     10#include <mruby/hash.h>
     11#include <mruby/khash.h>
     12#include <mruby/string.h>
     13#include <mruby/variable.h>
    1414
    1515/* a function to get hash value of a float number */
    … …  
    9292}
    9393
    94 typedef struct {
    95   mrb_value v;
    96   mrb_int n;
    97 } mrb_hash_value;
    98 
    99 KHASH_DECLARE(ht, mrb_value, mrb_hash_value, TRUE)
    10094KHASH_DEFINE (ht, mrb_value, mrb_hash_value, TRUE, mrb_hash_ht_hash_func, mrb_hash_ht_hash_equal)
    10195
    … …  
    10599mrb_hash_ht_key(mrb_state *mrb, mrb_value key)
    106100{
    107   if (mrb_string_p(key) && !RSTR_FROZEN_P(mrb_str_ptr(key))) {
     101  if (mrb_string_p(key) && !MRB_FROZEN_P(mrb_str_ptr(key))) {
    108102    key = mrb_str_dup(mrb, key);
    109     RSTR_SET_FROZEN_FLAG(mrb_str_ptr(key));
     103    MRB_SET_FROZEN_FLAG(mrb_str_ptr(key));
    110104  }
    111105  return key;
    … …  
    147141
    148142MRB_API mrb_value
    149 mrb_hash_new_capa(mrb_state *mrb, int capa)
     143mrb_hash_new_capa(mrb_state *mrb, mrb_int capa)
    150144{
    151145  struct RHash *h;
    … …  
    166160}
    167161
     162static mrb_value mrb_hash_default(mrb_state *mrb, mrb_value hash);
     163static mrb_value hash_default(mrb_state *mrb, mrb_value hash, mrb_value key);
     164
    168165MRB_API mrb_value
    169166mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
    … …  
    171168  khash_t(ht) *h = RHASH_TBL(hash);
    172169  khiter_t k;
     170  mrb_sym mid;
    173171
    174172  if (h) {
    … …  
    178176  }
    179177
    180   /* not found */
    181   if (MRB_RHASH_PROCDEFAULT_P(hash)) {
    182     return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
    183   }
    184   return RHASH_IFNONE(hash);
     178  mid = mrb_intern_lit(mrb, "default");
     179  if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) {
     180    return hash_default(mrb, hash, key);
     181  }
     182  /* xxx mrb_funcall_tailcall(mrb, hash, "default", 1, key); */
     183  return mrb_funcall_argv(mrb, hash, mid, 1, &key);
    185184}
    186185
    … …  
    234233  khash_t(ht) *h, *ret_h;
    235234  khiter_t k, ret_k;
     235  mrb_value ifnone, vret;
    236236
    237237  h = RHASH_TBL(hash);
    … …  
    239239  ret->ht = kh_init(ht, mrb);
    240240
    241   if (kh_size(h) > 0) {
     241  if (h && kh_size(h) > 0) {
    242242    ret_h = ret->ht;
    243243
    … …  
    247247        ret_k = kh_put(ht, mrb, ret_h, KEY(kh_key(h, k)));
    248248        mrb_gc_arena_restore(mrb, ai);
    249         kh_val(ret_h, ret_k) = kh_val(h, k);
     249        kh_val(ret_h, ret_k).v = kh_val(h, k).v;
     250        kh_val(ret_h, ret_k).n = kh_size(ret_h)-1;
    250251      }
    251252    }
    252253  }
    253254
    254   return mrb_obj_value(ret);
     255  if (MRB_RHASH_DEFAULT_P(hash)) {
     256    ret->flags |= MRB_HASH_DEFAULT;
     257  }
     258  if (MRB_RHASH_PROCDEFAULT_P(hash)) {
     259    ret->flags |= MRB_HASH_PROC_DEFAULT;
     260  }
     261  vret = mrb_obj_value(ret);
     262  ifnone = RHASH_IFNONE(hash);
     263  if (!mrb_nil_p(ifnone)) {
     264      mrb_iv_set(mrb, vret, mrb_intern_lit(mrb, "ifnone"), ifnone);
     265  }
     266  return vret;
    255267}
    256268
    … …  
    275287mrb_hash_modify(mrb_state *mrb, mrb_value hash)
    276288{
     289  if (MRB_FROZEN_P(mrb_hash_ptr(hash))) {
     290    mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen hash");
     291  }
    277292  mrb_hash_tbl(mrb, hash);
    278293}
    … …  
    330345    ifnone = block;
    331346  }
    332   mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
     347  if (!mrb_nil_p(ifnone)) {
     348    RHASH(hash)->flags |= MRB_HASH_DEFAULT;
     349    mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
     350  }
    333351  return hash;
    334352}
    … …  
    357375}
    358376
     377static mrb_value
     378hash_default(mrb_state *mrb, mrb_value hash, mrb_value key)
     379{
     380  if (MRB_RHASH_DEFAULT_P(hash)) {
     381    if (MRB_RHASH_PROCDEFAULT_P(hash)) {
     382      return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
     383    }
     384    else {
     385      return RHASH_IFNONE(hash);
     386    }
     387  }
     388  return mrb_nil_value();
     389}
     390
    359391/* 15.2.13.4.5  */
    360392/*
    … …  
    386418
    387419  mrb_get_args(mrb, "|o?", &key, &given);
    388   if (MRB_RHASH_PROCDEFAULT_P(hash)) {
    389     if (!given) return mrb_nil_value();
    390     return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
    391   }
    392   else {
    393     return RHASH_IFNONE(hash);
    394   }
     420  if (MRB_RHASH_DEFAULT_P(hash)) {
     421    if (MRB_RHASH_PROCDEFAULT_P(hash)) {
     422      if (!given) return mrb_nil_value();
     423      return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
     424    }
     425    else {
     426      return RHASH_IFNONE(hash);
     427    }
     428  }
     429  return mrb_nil_value();
    395430}
    396431
    … …  
    424459  mrb_hash_modify(mrb, hash);
    425460  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
    426   RHASH(hash)->flags &= ~(MRB_HASH_PROC_DEFAULT);
    427 
     461  RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
     462  if (!mrb_nil_p(ifnone)) {
     463    RHASH(hash)->flags |= MRB_HASH_DEFAULT;
     464  }
     465  else {
     466    RHASH(hash)->flags &= ~MRB_HASH_DEFAULT;
     467  }
    428468  return ifnone;
    429469}
    … …  
    475515  mrb_hash_modify(mrb, hash);
    476516  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
    477   RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
     517  if (!mrb_nil_p(ifnone)) {
     518    RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
     519    RHASH(hash)->flags |= MRB_HASH_DEFAULT;
     520  }
     521  else {
     522    RHASH(hash)->flags &= ~MRB_HASH_DEFAULT;
     523    RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
     524  }
    478525
    479526  return ifnone;
    … …  
    530577
    531578  mrb_get_args(mrb, "o", &key);
     579  mrb_hash_modify(mrb, self);
    532580  return mrb_hash_delete_key(mrb, self, key);
    533581}
    … …  
    568616  }
    569617
    570   if (MRB_RHASH_PROCDEFAULT_P(hash)) {
    571     return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value());
    572   }
    573   else {
    574     return RHASH_IFNONE(hash);
    575   }
     618  if (MRB_RHASH_DEFAULT_P(hash)) {
     619    if (MRB_RHASH_PROCDEFAULT_P(hash)) {
     620      return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value());
     621    }
     622    else {
     623      return RHASH_IFNONE(hash);
     624    }
     625  }
     626  return mrb_nil_value();
    576627}
    577628
    … …  
    593644  khash_t(ht) *h = RHASH_TBL(hash);
    594645
     646  mrb_hash_modify(mrb, hash);
    595647  if (h) kh_clear(ht, mrb, h);
    596648  return hash;
    … …  
    700752  khash_t(ht) *h = RHASH_TBL(hash);
    701753  khiter_t k;
     754  mrb_int end;
    702755  mrb_value ary;
    703756  mrb_value *p;
    … …  
    705758  if (!h || kh_size(h) == 0) return mrb_ary_new(mrb);
    706759  ary = mrb_ary_new_capa(mrb, kh_size(h));
    707   mrb_ary_set(mrb, ary, kh_size(h)-1, mrb_nil_value());
     760  end = kh_size(h)-1;
     761  mrb_ary_set(mrb, ary, end, mrb_nil_value());
    708762  p = mrb_ary_ptr(ary)->ptr;
    709763  for (k = kh_begin(h); k != kh_end(h); k++) {
    … …  
    712766      mrb_hash_value hv = kh_value(h, k);
    713767
    714       p[hv.n] = kv;
     768      if (hv.n <= end) {
     769        p[hv.n] = kv;
     770      }
     771      else {
     772        p[end] = kv;
     773      }
    715774    }
    716775  }
    … …  
    731790 */
    732791
    733 static mrb_value
     792MRB_API mrb_value
    734793mrb_hash_values(mrb_state *mrb, mrb_value hash)
    735794{

  • EcnlProtoTool/trunk/mruby-1.3.0/src/init.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
     7#include <mruby.h>
    88
    99void mrb_init_symtbl(mrb_state*);
    … …  
    1414void mrb_init_enumerable(mrb_state*);
    1515void mrb_init_symbol(mrb_state*);
     16void mrb_init_string(mrb_state*);
    1617void mrb_init_exception(mrb_state*);
    1718void mrb_init_proc(mrb_state*);
    18 void mrb_init_string(mrb_state*);
    1919void mrb_init_array(mrb_state*);
    2020void mrb_init_hash(mrb_state*);
    … …  
    3939
    4040  mrb_init_symbol(mrb); DONE;
     41  mrb_init_string(mrb); DONE;
    4142  mrb_init_exception(mrb); DONE;
    4243  mrb_init_proc(mrb); DONE;
    43   mrb_init_string(mrb); DONE;
    4444  mrb_init_array(mrb); DONE;
    4545  mrb_init_hash(mrb); DONE;

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

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/array.h"
    9 #include "mruby/class.h"
    10 #include "mruby/proc.h"
    11 #include "mruby/string.h"
    12 #include "mruby/variable.h"
    13 #include "mruby/error.h"
     7#include <mruby.h>
     8#include <mruby/array.h>
     9#include <mruby/hash.h>
     10#include <mruby/class.h>
     11#include <mruby/proc.h>
     12#include <mruby/string.h>
     13#include <mruby/variable.h>
     14#include <mruby/error.h>
     15#include <mruby/istruct.h>
    1416
    1517typedef enum {
    … …  
    2729} mrb_method_flag_t;
    2830
     31MRB_API mrb_bool
     32mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)
     33{
     34  struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mid);
     35  if (MRB_PROC_CFUNC_P(me) && (me->body.func == func))
     36    return TRUE;
     37  return FALSE;
     38}
     39
    2940static mrb_bool
    3041mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
    3142{
    32   struct RProc *me = mrb_method_search(mrb, mrb_class(mrb, obj), mrb_intern_lit(mrb, "to_s"));
    33   if (MRB_PROC_CFUNC_P(me) && (me->body.func == mrb_any_to_s))
    34     return TRUE;
    35   return FALSE;
     43  return mrb_func_basic_p(mrb, obj, mrb_intern_lit(mrb, "to_s"), mrb_any_to_s);
    3644}
    3745
    … …  
    5765  }
    5866  return mrb_any_to_s(mrb, obj);
    59 }
    60 
    61 /* 15.3.1.3.1  */
    62 /* 15.3.1.3.10 */
    63 /* 15.3.1.3.11 */
    64 /*
    65  *  call-seq:
    66  *     obj == other        -> true or false
    67  *     obj.equal?(other)   -> true or false
    68  *     obj.eql?(other)     -> true or false
    69  *
    70  *  Equality---At the <code>Object</code> level, <code>==</code> returns
    71  *  <code>true</code> only if <i>obj</i> and <i>other</i> are the
    72  *  same object. Typically, this method is overridden in descendant
    73  *  classes to provide class-specific meaning.
    74  *
    75  *  Unlike <code>==</code>, the <code>equal?</code> method should never be
    76  *  overridden by subclasses: it is used to determine object identity
    77  *  (that is, <code>a.equal?(b)</code> iff <code>a</code> is the same
    78  *  object as <code>b</code>).
    79  *
    80  *  The <code>eql?</code> method returns <code>true</code> if
    81  *  <i>obj</i> and <i>anObject</i> have the same value. Used by
    82  *  <code>Hash</code> to test members for equality.  For objects of
    83  *  class <code>Object</code>, <code>eql?</code> is synonymous with
    84  *  <code>==</code>. Subclasses normally continue this tradition, but
    85  *  there are exceptions. <code>Numeric</code> types, for example,
    86  *  perform type conversion across <code>==</code>, but not across
    87  *  <code>eql?</code>, so:
    88  *
    89  *     1 == 1.0     #=> true
    90  *     1.eql? 1.0   #=> false
    91  */
    92 static mrb_value
    93 mrb_obj_equal_m(mrb_state *mrb, mrb_value self)
    94 {
    95   mrb_value arg;
    96 
    97   mrb_get_args(mrb, "o", &arg);
    98   return mrb_bool_value(mrb_obj_equal(mrb, self, arg));
    99 }
    100 
    101 static mrb_value
    102 mrb_obj_not_equal_m(mrb_state *mrb, mrb_value self)
    103 {
    104   mrb_value arg;
    105 
    106   mrb_get_args(mrb, "o", &arg);
    107   return mrb_bool_value(!mrb_equal(mrb, self, arg));
    10867}
    10968
    … …  
    143102 *  <code>name</code>. Replaces the deprecated <code>Object#id</code>.
    144103 */
    145 static mrb_value
     104mrb_value
    146105mrb_obj_id_m(mrb_state *mrb, mrb_value self)
    147106{
    … …  
    178137  mrb_callinfo *ci = mrb->c->ci;
    179138  mrb_value *bp;
    180   mrb_bool given_p;
    181139
    182140  bp = ci->stackent + 1;
    183141  ci--;
    184142  if (ci <= mrb->c->cibase) {
    185     given_p = FALSE;
    186   }
    187   else {
    188     /* block_given? called within block; check upper scope */
    189     if (ci->proc->env) {
    190       struct REnv *e = ci->proc->env;
    191       mrb_value *sp;
    192 
    193       while (e->c) {
    194         e = (struct REnv*)e->c;
    195       }
    196       sp = e->stack;
    197       if (sp) {
    198         /* top-level does not have block slot (alway false) */
    199         if (sp == mrb->c->stbase)
    200           return mrb_false_value();
    201         ci = mrb->c->cibase + e->cioff;
    202         bp = ci[1].stackent + 1;
    203       }
    204     }
    205     if (ci->argc > 0) {
    206       bp += ci->argc;
    207     }
    208     given_p = !mrb_nil_p(*bp);
    209   }
    210 
    211   return mrb_bool_value(given_p);
     143    return mrb_false_value();
     144  }
     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    }
     152    /* top-level does not have block slot (always false) */
     153    if (e->stack == mrb->c->stbase)
     154      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 */
     159    }
     160    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;
     167  }
     168  if (mrb_nil_p(*bp))
     169    return mrb_false_value();
     170  return mrb_true_value();
    212171}
    213172
    … …  
    241200    struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
    242201
    243     if ((mrb_type(obj) == MRB_TT_CLASS) || (mrb_type(obj) == MRB_TT_SCLASS)) {
    244       clone->c = clone;
    245     }
    246     else {
     202    switch (mrb_type(obj)) {
     203    case MRB_TT_CLASS:
     204    case MRB_TT_SCLASS:
     205      break;
     206    default:
    247207      clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
     208      break;
    248209    }
    249210    clone->super = klass->super;
    … …  
    283244    c1->super->flags |= MRB_FLAG_IS_ORIGIN;
    284245  }
    285   dc->mt = kh_copy(mt, mrb, sc->mt);
     246  if (sc->mt) {
     247    dc->mt = kh_copy(mt, mrb, sc->mt);
     248  }
     249  else {
     250    dc->mt = kh_init(mt, mrb);
     251  }
    286252  dc->super = sc->super;
     253  MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc));
    287254}
    288255
    … …  
    302269      mrb_iv_copy(mrb, dest, obj);
    303270      break;
     271    case MRB_TT_ISTRUCT:
     272      mrb_istruct_copy(dest, obj);
     273      break;
    304274
    305275    default:
    … …  
    441411  mrb_value *argv;
    442412  mrb_int argc;
     413  mrb_value args;
    443414
    444415  mrb_get_args(mrb, "*", &argv, &argc);
     416  args = mrb_ary_new_from_values(mrb, argc, argv);
     417  argv = (mrb_value*)RARRAY_PTR(args);
    445418  return mrb_obj_extend(mrb, argc, argv, self);
     419}
     420
     421static mrb_value
     422mrb_obj_freeze(mrb_state *mrb, mrb_value self)
     423{
     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);
     440  }
     441  return self;
     442}
     443
     444static mrb_value
     445mrb_obj_frozen(mrb_state *mrb, mrb_value self)
     446{
     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();
    446465}
    447466
    … …  
    477496}
    478497
    479 
    480 /* implementation of instance_eval */
    481 mrb_value mrb_obj_instance_eval(mrb_state*, mrb_value);
    482498
    483499MRB_API mrb_bool
    … …  
    723739mrb_obj_methods(mrb_state *mrb, mrb_bool recur, mrb_value obj, mrb_method_flag_t flag)
    724740{
    725   if (recur)
    726     return mrb_class_instance_method_list(mrb, recur, mrb_class(mrb, obj), 0);
    727   return mrb_obj_singleton_methods(mrb, recur, obj);
     741  return mrb_class_instance_method_list(mrb, recur, mrb_class(mrb, obj), 0);
    728742}
    729743/* 15.3.1.3.31 */
    … …  
    853867    break;
    854868  case 1:
    855     a[1] = mrb_check_string_type(mrb, a[0]);
    856     if (!mrb_nil_p(a[1])) {
     869    if (mrb_string_p(a[0])) {
     870      a[1] = a[0];
    857871      argc = 2;
    858872      a[0] = mrb_obj_value(E_RUNTIME_ERROR);
    … …  
    861875  default:
    862876    exc = mrb_make_exception(mrb, argc, a);
    863     mrb_obj_iv_set(mrb, mrb_obj_ptr(exc), mrb_intern_lit(mrb, "lastpc"), mrb_cptr_value(mrb, mrb->c->ci->pc));
    864877    mrb_exc_raise(mrb, exc);
    865878    break;
    … …  
    905918}
    906919
     920void
     921mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args)
     922{
     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);
     943}
     944
     945/* 15.3.1.3.30 */
     946/*
     947 *  call-seq:
     948 *     obj.method_missing(symbol [, *args] )   -> result
     949 *
     950 *  Invoked by Ruby when <i>obj</i> is sent a message it cannot handle.
     951 *  <i>symbol</i> is the symbol for the method called, and <i>args</i>
     952 *  are any arguments that were passed to it. By default, the interpreter
     953 *  raises an error when this method is called. However, it is possible
     954 *  to override the method to provide more dynamic behavior.
     955 *  If it is decided that a particular method should not be handled, then
     956 *  <i>super</i> should be called, so that ancestors can pick up the
     957 *  missing method.
     958 *  The example below creates
     959 *  a class <code>Roman</code>, which responds to methods with names
     960 *  consisting of roman numerals, returning the corresponding integer
     961 *  values.
     962 *
     963 *     class Roman
     964 *       def romanToInt(str)
     965 *         # ...
     966 *       end
     967 *       def method_missing(methId)
     968 *         str = methId.id2name
     969 *         romanToInt(str)
     970 *       end
     971 *     end
     972 *
     973 *     r = Roman.new
     974 *     r.iv      #=> 4
     975 *     r.xxiii   #=> 23
     976 *     r.mm      #=> 2000
     977 */
     978#ifdef MRB_DEFAULT_METHOD_MISSING
     979static mrb_value
     980mrb_obj_missing(mrb_state *mrb, mrb_value mod)
     981{
     982  mrb_sym name;
     983  mrb_value *a;
     984  mrb_int alen;
     985
     986  mrb_get_args(mrb, "n*", &name, &a, &alen);
     987  mrb_method_missing(mrb, name, mod, mrb_ary_new_from_values(mrb, alen, a));
     988  /* not reached */
     989  return mrb_nil_value();
     990}
     991#endif
     992
    907993static inline mrb_bool
    908994basic_obj_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym id, int pub)
    … …  
    9401026  else {
    9411027    mrb_value tmp;
    942     if (!mrb_string_p(mid)) {
     1028    if (mrb_string_p(mid)) {
     1029      tmp = mrb_check_intern_str(mrb, mid);
     1030    }
     1031    else {
    9431032      tmp = mrb_check_string_type(mrb, mid);
    9441033      if (mrb_nil_p(tmp)) {
    … …  
    9461035        mrb_raisef(mrb, E_TYPE_ERROR, "%S is not a symbol", tmp);
    9471036      }
    948     }
    949     tmp = mrb_check_intern_str(mrb, mid);
     1037      tmp = mrb_check_intern_str(mrb, tmp);
     1038    }
    9501039    if (mrb_nil_p(tmp)) {
    9511040      respond_to_p = FALSE;
    … …  
    9631052    rtm_id = mrb_intern_lit(mrb, "respond_to_missing?");
    9641053    if (basic_obj_respond_to(mrb, self, rtm_id, !priv)) {
    965       mrb_value args[2];
     1054      mrb_value args[2], v;
    9661055      args[0] = mid;
    9671056      args[1] = mrb_bool_value(priv);
    968       return mrb_funcall_argv(mrb, self, rtm_id, 2, args);
     1057      v = mrb_funcall_argv(mrb, self, rtm_id, 2, args);
     1058      return mrb_bool_value(mrb_bool(v));
    9691059    }
    9701060  }
    … …  
    10511141mrb_local_variables(mrb_state *mrb, mrb_value self)
    10521142{
    1053   mrb_value ret;
    10541143  struct RProc *proc;
     1144  mrb_value vars;
    10551145  struct mrb_irep *irep;
    10561146  size_t i;
    … …  
    10661156    return mrb_ary_new(mrb);
    10671157  }
    1068   ret = mrb_ary_new_capa(mrb, irep->nlocals - 1);
     1158  vars = mrb_hash_new(mrb);
    10691159  for (i = 0; i + 1 < irep->nlocals; ++i) {
    10701160    if (irep->lv[i].name) {
    1071       mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name));
     1161      mrb_hash_set(mrb, vars, mrb_symbol_value(irep->lv[i].name), mrb_true_value());
    10721162    }
    10731163  }
    … …  
    10761166
    10771167    while (e) {
    1078       if (!MRB_PROC_CFUNC_P(mrb->c->cibase[e->cioff].proc)) {
    1079         irep = mrb->c->cibase[e->cioff].proc->body.irep;
     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;
    10801171        if (irep->lv) {
    10811172          for (i = 0; i + 1 < irep->nlocals; ++i) {
    10821173            if (irep->lv[i].name) {
    1083               mrb_ary_push(mrb, ret, mrb_symbol_value(irep->lv[i].name));
     1174              mrb_hash_set(mrb, vars, mrb_symbol_value(irep->lv[i].name), mrb_true_value());
    10841175            }
    10851176          }
    … …  
    10901181  }
    10911182
    1092   return ret;
    1093 }
    1094 
     1183  return mrb_hash_keys(mrb, vars);
     1184}
     1185
     1186mrb_value mrb_obj_equal_m(mrb_state *mrb, mrb_value);
    10951187void
    10961188mrb_init_kernel(mrb_state *mrb)
    … …  
    11081200  mrb_define_method(mrb, krn, "singleton_class",            mrb_singleton_class,             MRB_ARGS_NONE());
    11091201
    1110   mrb_define_method(mrb, krn, "==",                         mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.1  */
    1111   mrb_define_method(mrb, krn, "!=",                         mrb_obj_not_equal_m,             MRB_ARGS_REQ(1));
    11121202  mrb_define_method(mrb, krn, "===",                        mrb_equal_m,                     MRB_ARGS_REQ(1));    /* 15.3.1.3.2  */
    1113   mrb_define_method(mrb, krn, "__id__",                     mrb_obj_id_m,                    MRB_ARGS_NONE());    /* 15.3.1.3.3  */
    1114   mrb_define_method(mrb, krn, "__send__",                   mrb_f_send,                      MRB_ARGS_ANY());     /* 15.3.1.3.4  */
    11151203  mrb_define_method(mrb, krn, "block_given?",               mrb_f_block_given_p_m,           MRB_ARGS_NONE());    /* 15.3.1.3.6  */
    11161204  mrb_define_method(mrb, krn, "class",                      mrb_obj_class_m,                 MRB_ARGS_NONE());    /* 15.3.1.3.7  */
    … …  
    11201208  mrb_define_method(mrb, krn, "equal?",                     mrb_obj_equal_m,                 MRB_ARGS_REQ(1));    /* 15.3.1.3.11 */
    11211209  mrb_define_method(mrb, krn, "extend",                     mrb_obj_extend_m,                MRB_ARGS_ANY());     /* 15.3.1.3.13 */
     1210  mrb_define_method(mrb, krn, "freeze",                     mrb_obj_freeze,                  MRB_ARGS_NONE());
     1211  mrb_define_method(mrb, krn, "frozen?",                    mrb_obj_frozen,                  MRB_ARGS_NONE());
    11221212  mrb_define_method(mrb, krn, "global_variables",           mrb_f_global_variables,          MRB_ARGS_NONE());    /* 15.3.1.3.14 */
    11231213  mrb_define_method(mrb, krn, "hash",                       mrb_obj_hash,                    MRB_ARGS_NONE());    /* 15.3.1.3.15 */
    11241214  mrb_define_method(mrb, krn, "initialize_copy",            mrb_obj_init_copy,               MRB_ARGS_REQ(1));    /* 15.3.1.3.16 */
    11251215  mrb_define_method(mrb, krn, "inspect",                    mrb_obj_inspect,                 MRB_ARGS_NONE());    /* 15.3.1.3.17 */
    1126   mrb_define_method(mrb, krn, "instance_eval",              mrb_obj_instance_eval,           MRB_ARGS_ANY());     /* 15.3.1.3.18 */
    11271216  mrb_define_method(mrb, krn, "instance_of?",               obj_is_instance_of,              MRB_ARGS_REQ(1));    /* 15.3.1.3.19 */
    11281217  mrb_define_method(mrb, krn, "instance_variable_defined?", mrb_obj_ivar_defined,            MRB_ARGS_REQ(1));    /* 15.3.1.3.20 */
    … …  
    11341223  mrb_define_method(mrb, krn, "kind_of?",                   mrb_obj_is_kind_of_m,            MRB_ARGS_REQ(1));    /* 15.3.1.3.26 */
    11351224  mrb_define_method(mrb, krn, "local_variables",            mrb_local_variables,             MRB_ARGS_NONE());    /* 15.3.1.3.28 */
     1225#ifdef MRB_DEFAULT_METHOD_MISSING
     1226  mrb_define_method(mrb, krn, "method_missing",             mrb_obj_missing,                 MRB_ARGS_ANY());     /* 15.3.1.3.30 */
     1227#endif
    11361228  mrb_define_method(mrb, krn, "methods",                    mrb_obj_methods_m,               MRB_ARGS_OPT(1));    /* 15.3.1.3.31 */
    11371229  mrb_define_method(mrb, krn, "nil?",                       mrb_false,                       MRB_ARGS_NONE());    /* 15.3.1.3.32 */

  • EcnlProtoTool/trunk/mruby-1.3.0/src/load.c

    r321 r331  
    88#include <stdlib.h>
    99#include <string.h>
    10 #include "mruby/dump.h"
    11 #include "mruby/irep.h"
    12 #include "mruby/proc.h"
    13 #include "mruby/string.h"
    14 #include "mruby/debug.h"
    15 #include "mruby/error.h"
     10#include <mruby/dump.h>
     11#include <mruby/irep.h>
     12#include <mruby/proc.h>
     13#include <mruby/string.h>
     14#include <mruby/debug.h>
     15#include <mruby/error.h>
    1616
    1717#if SIZE_MAX < UINT32_MAX
    … …  
    524524    if (bigendian_p())
    525525      *flags |= FLAG_BYTEORDER_NATIVE;
    526     else 
     526    else
    527527      *flags |= FLAG_BYTEORDER_BIG;
    528528  }
    … …  
    545545}
    546546
    547 MRB_API mrb_irep*
     547static mrb_irep*
    548548read_irep(mrb_state *mrb, const uint8_t *bin, uint8_t flags)
    549549{
    … …  
    603603}
    604604
    605 MRB_API mrb_irep*
     605mrb_irep*
    606606mrb_read_irep(mrb_state *mrb, const uint8_t *bin)
    607607{
    … …  
    615615}
    616616
     617void mrb_exc_set(mrb_state *mrb, mrb_value exc);
     618
    617619static void
    618620irep_error(mrb_state *mrb)
    619621{
    620   mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
     622  mrb_exc_set(mrb, mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
    621623}
    622624
    … …  
    634636  mrb_irep_decref(mrb, irep);
    635637  if (c && c->no_exec) return mrb_obj_value(proc);
    636   return mrb_toplevel_run(mrb, proc);
     638  return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
    637639}
    638640
    … …  
    645647#ifndef MRB_DISABLE_STDIO
    646648
    647 MRB_API mrb_irep*
     649mrb_irep*
    648650mrb_read_irep_file(mrb_state *mrb, FILE* fp)
    649651{
    … …  
    696698  if (c && c->dump_result) mrb_codedump_all(mrb, proc);
    697699  if (c && c->no_exec) return mrb_obj_value(proc);
    698   val = mrb_toplevel_run(mrb, proc);
     700  val = mrb_top_run(mrb, proc, mrb_top_self(mrb), 0);
    699701  return val;
    700702}

  • EcnlProtoTool/trunk/mruby-1.3.0/src/mruby_core.rake

    r321 r331  
    55
    66  objs = Dir.glob("#{current_dir}/*.c").map { |f|
    7     next nil if cxx_abi_enabled? and f =~ /(error|vm).c$/
     7    next nil if cxx_exception_enabled? and f =~ /(error|vm).c$/
    88    objfile(f.pathmap("#{current_build_dir}/%n"))
    99  }.compact
    1010
    11   if cxx_abi_enabled?
     11  if cxx_exception_enabled?
    1212    objs += %w(vm error).map { |v| compile_as_cxx "#{current_dir}/#{v}.c", "#{current_build_dir}/#{v}.cxx" }
    1313  end

  • EcnlProtoTool/trunk/mruby-1.3.0/src/numeric.c

    r321 r331  
    1010#include <stdlib.h>
    1111
    12 #include "mruby.h"
    13 #include "mruby/array.h"
    14 #include "mruby/numeric.h"
    15 #include "mruby/string.h"
     12#include <mruby.h>
     13#include <mruby/array.h>
     14#include <mruby/numeric.h>
     15#include <mruby/string.h>
     16#include <mruby/class.h>
    1617
    1718#ifdef MRB_USE_FLOAT
     19#define trunc(f) truncf(f)
    1820#define floor(f) floorf(f)
    1921#define ceil(f) ceilf(f)
    … …  
    5153{
    5254  mrb_value y;
    53   mrb_float d, yv;
    54 
    55   mrb_get_args(mrb, "o", &y);
    56   yv = mrb_to_flo(mrb, y);
    57   d = pow(mrb_to_flo(mrb, x), yv);
    58   if (mrb_fixnum_p(x) && mrb_fixnum_p(y) && FIXABLE(d) && yv > 0 &&
    59       (d < 0 || (d > 0 && (mrb_int)d > 0)))
    60     return mrb_fixnum_value((mrb_int)d);
     55  mrb_float d;
     56
     57  mrb_get_args(mrb, "o", &y);
     58  if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) {
     59    /* try ipow() */
     60    mrb_int base = mrb_fixnum(x);
     61    mrb_int exp = mrb_fixnum(y);
     62    mrb_int result = 1;
     63
     64    if (exp < 0) goto float_pow;
     65    for (;;) {
     66      if (exp & 1) {
     67        if (mrb_int_mul_overflow(result, base, &result)) {
     68          goto float_pow;
     69        }
     70      }
     71      exp >>= 1;
     72      if (exp == 0) break;
     73      if (mrb_int_mul_overflow(base, base, &base)) {
     74        goto float_pow;
     75      }
     76    }
     77    return mrb_fixnum_value(result);
     78  }
     79 float_pow:
     80  d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
    6181  return mrb_float_value(mrb, d);
    6282}
    … …  
    272292}
    273293
     294static int64_t
     295value_int64(mrb_state *mrb, mrb_value x)
     296{
     297  switch (mrb_type(x)) {
     298  case MRB_TT_FIXNUM:
     299    return (int64_t)mrb_fixnum(x);
     300    break;
     301  case MRB_TT_FLOAT:
     302    return (int64_t)mrb_float(x);
     303  default:
     304    mrb_raise(mrb, E_TYPE_ERROR, "cannot convert to Integer");
     305    break;
     306  }
     307  /* not reached */
     308  return 0;
     309}
     310
     311static mrb_value
     312int64_value(mrb_state *mrb, int64_t v)
     313{
     314  if (FIXABLE(v)) {
     315    return mrb_fixnum_value((mrb_int)v);
     316  }
     317  return mrb_float_value(mrb, (mrb_float)v);
     318}
     319
     320static mrb_value
     321flo_rev(mrb_state *mrb, mrb_value x)
     322{
     323  int64_t v1;
     324  mrb_get_args(mrb, "");
     325  v1 = (int64_t)mrb_float(x);
     326  return int64_value(mrb, ~v1);
     327}
     328
     329static mrb_value
     330flo_and(mrb_state *mrb, mrb_value x)
     331{
     332  mrb_value y;
     333  int64_t v1, v2;
     334  mrb_get_args(mrb, "o", &y);
     335
     336  v1 = (int64_t)mrb_float(x);
     337  v2 = value_int64(mrb, y);
     338  return int64_value(mrb, v1 & v2);
     339}
     340
     341static mrb_value
     342flo_or(mrb_state *mrb, mrb_value x)
     343{
     344  mrb_value y;
     345  int64_t v1, v2;
     346  mrb_get_args(mrb, "o", &y);
     347
     348  v1 = (int64_t)mrb_float(x);
     349  v2 = value_int64(mrb, y);
     350  return int64_value(mrb, v1 | v2);
     351}
     352
     353static mrb_value
     354flo_xor(mrb_state *mrb, mrb_value x)
     355{
     356  mrb_value y;
     357  int64_t v1, v2;
     358  mrb_get_args(mrb, "o", &y);
     359
     360  v1 = (int64_t)mrb_float(x);
     361  v2 = value_int64(mrb, y);
     362  return int64_value(mrb, v1 ^ v2);
     363}
     364
     365static mrb_value
     366flo_shift(mrb_state *mrb, mrb_value x, mrb_int width)
     367{
     368  mrb_float val;
     369
     370  if (width == 0) {
     371    return x;
     372  }
     373  val = mrb_float(x);
     374  if (width < 0) {
     375    while (width++) {
     376      val /= 2;
     377    }
     378#if defined(_ISOC99_SOURCE)
     379    val = trunc(val);
     380#else
     381    val = val > 0 ? floor(val) : ceil(val);
     382#endif
     383    if (val == 0 && mrb_float(x) < 0) {
     384      return mrb_fixnum_value(-1);
     385    }
     386  }
     387  else {
     388    while (width--) {
     389      val *= 2;
     390    }
     391  }
     392  if (FIXABLE_FLOAT(val)) {
     393    return mrb_fixnum_value((mrb_int)val);
     394  }
     395  return mrb_float_value(mrb, val);
     396}
     397
     398static mrb_value
     399flo_lshift(mrb_state *mrb, mrb_value x)
     400{
     401  mrb_int width;
     402
     403  mrb_get_args(mrb, "i", &width);
     404  return flo_shift(mrb, x, -width);
     405}
     406
     407static mrb_value
     408flo_rshift(mrb_state *mrb, mrb_value x)
     409{
     410  mrb_int width;
     411
     412  mrb_get_args(mrb, "i", &width);
     413  return flo_shift(mrb, x, width);
     414}
     415
    274416/* 15.2.8.3.18 */
    275417/*
    … …  
    285427  char *c;
    286428  size_t i;
    287   int hash;
     429  mrb_int hash;
    288430
    289431  d = (mrb_float)mrb_fixnum(num);
    … …  
    291433  if (d == 0) d = 0.0;
    292434  c = (char*)&d;
    293   for (hash=0, i=0; i<sizeof(mrb_float);i++) {
     435  for (hash=0,i=0; i<sizeof(mrb_float); i++) {
    294436    hash = (hash * 971) ^ (unsigned char)c[i];
    295437  }
    … …  
    351493{
    352494  return mrb_bool_value(isfinite(mrb_float(num)));
     495}
     496
     497void
     498mrb_check_num_exact(mrb_state *mrb, mrb_float num)
     499{
     500  if (isinf(num)) {
     501    mrb_raise(mrb, E_FLOATDOMAIN_ERROR, num < 0 ? "-Infinity" : "Infinity");
     502  }
     503  if (isnan(num)) {
     504    mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
     505  }
    353506}
    354507
    … …  
    371524  mrb_float f = floor(mrb_float(num));
    372525
    373   if (!FIXABLE(f)) {
     526  mrb_check_num_exact(mrb, f);
     527  if (!FIXABLE_FLOAT(f)) {
    374528    return mrb_float_value(mrb, f);
    375529  }
    … …  
    396550  mrb_float f = ceil(mrb_float(num));
    397551
    398   if (!FIXABLE(f)) {
     552  mrb_check_num_exact(mrb, f);
     553  if (!FIXABLE_FLOAT(f)) {
    399554    return mrb_float_value(mrb, f);
    400555  }
    … …  
    443598  number = mrb_float(num);
    444599
    445   if (isinf(number)) {
    446     if (0 < ndigits) return num;
    447     else mrb_raise(mrb, E_FLOATDOMAIN_ERROR, number < 0 ? "-Infinity" : "Infinity");
    448   }
    449   if (isnan(number)) {
    450     if (0 < ndigits) return num;
    451     else mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
    452   }
     600  if (0 < ndigits && (isinf(number) || isnan(number))) {
     601    return num;
     602  }
     603  mrb_check_num_exact(mrb, number);
    453604
    454605  f = 1.0;
    … …  
    506657  if (f < 0.0) f = ceil(f);
    507658
    508   if (!FIXABLE(f)) {
     659  mrb_check_num_exact(mrb, f);
     660  if (!FIXABLE_FLOAT(f)) {
    509661    return mrb_float_value(mrb, f);
    510662  }
    … …  
    542694}
    543695
    544 /*tests if N*N would overflow*/
    545 #define SQRT_INT_MAX ((mrb_int)1<<((MRB_INT_BIT-1-MRB_FIXNUM_SHIFT)/2))
    546 #define FIT_SQRT_INT(n) (((n)<SQRT_INT_MAX)&&((n)>=-SQRT_INT_MAX))
    547 
    548696mrb_value
    549697mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
    … …  
    553701  a = mrb_fixnum(x);
    554702  if (mrb_fixnum_p(y)) {
    555     mrb_float c;
    556     mrb_int b;
     703    mrb_int b, c;
    557704
    558705    if (a == 0) return x;
    559706    b = mrb_fixnum(y);
    560     if (FIT_SQRT_INT(a) && FIT_SQRT_INT(b))
    561       return mrb_fixnum_value(a*b);
    562     c = a * b;
    563     if ((a != 0 && c/a != b) || !FIXABLE(c)) {
    564       return mrb_float_value(mrb, (mrb_float)a*(mrb_float)b);
    565     }
    566     return mrb_fixnum_value((mrb_int)c);
     707    if (mrb_int_mul_overflow(a, b, &c)) {
     708      return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b);
     709    }
     710    return mrb_fixnum_value(c);
    567711  }
    568712  return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y));
    … …  
    747891}
    748892
    749 static mrb_value
    750 bit_coerce(mrb_state *mrb, mrb_value x)
    751 {
    752   while (!mrb_fixnum_p(x)) {
    753     if (mrb_float_p(x)) {
    754       mrb_raise(mrb, E_TYPE_ERROR, "can't convert Float into Integer");
    755     }
    756     x = mrb_to_int(mrb, x);
    757   }
    758   return x;
    759 }
     893static mrb_value flo_and(mrb_state *mrb, mrb_value x);
     894static mrb_value flo_or(mrb_state *mrb, mrb_value x);
     895static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
     896#define bit_op(x,y,op1,op2) do {\
     897  if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
     898  return flo_ ## op1(mrb, mrb_float_value(mrb, mrb_fixnum(x)));\
     899} while(0)
    760900
    761901/* 15.2.8.3.9  */
    … …  
    773913
    774914  mrb_get_args(mrb, "o", &y);
    775 
    776   y = bit_coerce(mrb, y);
    777   return mrb_fixnum_value(mrb_fixnum(x) & mrb_fixnum(y));
     915  bit_op(x, y, and, &);
    778916}
    779917
    … …  
    792930
    793931  mrb_get_args(mrb, "o", &y);
    794 
    795   y = bit_coerce(mrb, y);
    796   return mrb_fixnum_value(mrb_fixnum(x) | mrb_fixnum(y));
     932  bit_op(x, y, or, |);
    797933}
    798934
    … …  
    811947
    812948  mrb_get_args(mrb, "o", &y);
    813 
    814   y = bit_coerce(mrb, y);
    815   return mrb_fixnum_value(mrb_fixnum(x) ^ mrb_fixnum(y));
     949  bit_op(x, y, or, ^);
    816950}
    817951
    … …  
    821955lshift(mrb_state *mrb, mrb_int val, mrb_int width)
    822956{
    823   mrb_assert(width > 0);
    824   if (width > NUMERIC_SHIFT_WIDTH_MAX) {
     957  if (width < 0) {              /* mrb_int overflow */
     958    return mrb_float_value(mrb, INFINITY);
     959  }
     960  if (val > 0) {
     961    if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
     962        (val   > (MRB_INT_MAX >> width))) {
     963      goto bit_overflow;
     964    }
     965  }
     966  else {
     967    if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
     968        (val   < (MRB_INT_MIN >> width))) {
     969      goto bit_overflow;
     970    }
     971  }
     972
     973  return mrb_fixnum_value(val << width);
     974
     975bit_overflow:
     976  {
    825977    mrb_float f = (mrb_float)val;
    826978    while (width--) {
    … …  
    829981    return mrb_float_value(mrb, f);
    830982  }
    831   return mrb_fixnum_value(val << width);
    832983}
    833984
    … …  
    835986rshift(mrb_int val, mrb_int width)
    836987{
    837   mrb_assert(width > 0);
     988  if (width < 0) {              /* mrb_int overflow */
     989    return mrb_fixnum_value(0);
     990  }
    838991  if (width >= NUMERIC_SHIFT_WIDTH_MAX) {
    839992    if (val < 0) {
    … …  
    845998}
    846999
    847 static inline void
    848 fix_shift_get_width(mrb_state *mrb, mrb_int *width)
    849 {
    850   mrb_value y;
    851 
    852   mrb_get_args(mrb, "o", &y);
    853   *width = mrb_fixnum(bit_coerce(mrb, y));
    854 }
    855 
    8561000/* 15.2.8.3.12 */
    8571001/*
    … …  
    8671011  mrb_int width, val;
    8681012
    869   fix_shift_get_width(mrb, &width);
    870 
     1013  mrb_get_args(mrb, "i", &width);
    8711014  if (width == 0) {
    8721015    return x;
    8731016  }
    8741017  val = mrb_fixnum(x);
     1018  if (val == 0) return x;
    8751019  if (width < 0) {
    8761020    return rshift(val, -width);
    … …  
    8921036  mrb_int width, val;
    8931037
    894   fix_shift_get_width(mrb, &width);
    895 
     1038  mrb_get_args(mrb, "i", &width);
    8961039  if (width == 0) {
    8971040    return x;
    8981041  }
    8991042  val = mrb_fixnum(x);
     1043  if (val == 0) return x;
    9001044  if (width < 0) {
    9011045    return lshift(mrb, val, -width);
    … …  
    9361080mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
    9371081{
    938   mrb_int z;
     1082  mrb_int z = 0;
    9391083
    9401084  if (!mrb_float_p(x)) {
    … …  
    9511095      mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
    9521096    }
    953     z = (mrb_int)d;
     1097    if (FIXABLE_FLOAT(d)) {
     1098      z = (mrb_int)d;
     1099    }
     1100    else {
     1101      mrb_raisef(mrb, E_ARGUMENT_ERROR, "number (%S) too big for integer", x);
     1102    }
    9541103  }
    9551104  return mrb_fixnum_value(z);
    … …  
    11501299  numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);                /* 15.2.7 */
    11511300
    1152   mrb_define_method(mrb, numeric, "**",       num_pow,        MRB_ARGS_REQ(1));
    1153   mrb_define_method(mrb, numeric, "/",        num_div,        MRB_ARGS_REQ(1)); /* 15.2.8.3.4  */
    1154   mrb_define_method(mrb, numeric, "quo",      num_div,        MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
    1155   mrb_define_method(mrb, numeric, "<=>",      num_cmp,        MRB_ARGS_REQ(1)); /* 15.2.9.3.6  */
     1301  mrb_define_method(mrb, numeric, "**",       num_pow,         MRB_ARGS_REQ(1));
     1302  mrb_define_method(mrb, numeric, "/",        num_div,         MRB_ARGS_REQ(1)); /* 15.2.8.3.4  */
     1303  mrb_define_method(mrb, numeric, "quo",      num_div,         MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
     1304  mrb_define_method(mrb, numeric, "<=>",      num_cmp,         MRB_ARGS_REQ(1)); /* 15.2.9.3.6  */
    11561305
    11571306  /* Integer Class */
    11581307  integer = mrb_define_class(mrb, "Integer",  numeric);                          /* 15.2.8 */
     1308  MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM);
    11591309  mrb_undef_class_method(mrb, integer, "new");
    1160   mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE());            /* 15.2.8.3.24 */
    1161   mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE());
     1310  mrb_define_method(mrb, integer, "to_i",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.24 */
     1311  mrb_define_method(mrb, integer, "to_int",   int_to_i,        MRB_ARGS_NONE());
     1312  mrb_define_method(mrb, integer, "ceil",     int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.8 (x) */
     1313  mrb_define_method(mrb, integer, "floor",    int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.10 (x) */
     1314  mrb_define_method(mrb, integer, "round",    int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.12 (x) */
     1315  mrb_define_method(mrb, integer, "truncate", int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.15 (x) */
    11621316
    11631317  /* Fixnum Class */
    11641318  mrb->fixnum_class = fixnum = mrb_define_class(mrb, "Fixnum", integer);
    1165   mrb_define_method(mrb, fixnum,  "+",        fix_plus,          MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
    1166   mrb_define_method(mrb, fixnum,  "-",        fix_minus,         MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
    1167   mrb_define_method(mrb, fixnum,  "*",        fix_mul,           MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
    1168   mrb_define_method(mrb, fixnum,  "%",        fix_mod,           MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
    1169   mrb_define_method(mrb, fixnum,  "==",       fix_equal,         MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
    1170   mrb_define_method(mrb, fixnum,  "~",        fix_rev,           MRB_ARGS_NONE()); /* 15.2.8.3.8  */
    1171   mrb_define_method(mrb, fixnum,  "&",        fix_and,           MRB_ARGS_REQ(1)); /* 15.2.8.3.9  */
    1172   mrb_define_method(mrb, fixnum,  "|",        fix_or,            MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
    1173   mrb_define_method(mrb, fixnum,  "^",        fix_xor,           MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
    1174   mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
    1175   mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
    1176   mrb_define_method(mrb, fixnum,  "eql?",     fix_eql,           MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
    1177   mrb_define_method(mrb, fixnum,  "hash",     flo_hash,          MRB_ARGS_NONE()); /* 15.2.8.3.18 */
    1178   mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,          MRB_ARGS_NONE()); /* 15.2.8.3.23 */
    1179   mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,          MRB_ARGS_NONE()); /* 15.2.8.3.25 */
    1180   mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,          MRB_ARGS_NONE());
    1181   mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,        MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
     1319  mrb_define_method(mrb, fixnum,  "+",        fix_plus,        MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
     1320  mrb_define_method(mrb, fixnum,  "-",        fix_minus,       MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
     1321  mrb_define_method(mrb, fixnum,  "*",        fix_mul,         MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
     1322  mrb_define_method(mrb, fixnum,  "%",        fix_mod,         MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
     1323  mrb_define_method(mrb, fixnum,  "==",       fix_equal,       MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
     1324  mrb_define_method(mrb, fixnum,  "~",        fix_rev,         MRB_ARGS_NONE()); /* 15.2.8.3.8  */
     1325  mrb_define_method(mrb, fixnum,  "&",        fix_and,         MRB_ARGS_REQ(1)); /* 15.2.8.3.9  */
     1326  mrb_define_method(mrb, fixnum,  "|",        fix_or,          MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
     1327  mrb_define_method(mrb, fixnum,  "^",        fix_xor,         MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
     1328  mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
     1329  mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
     1330  mrb_define_method(mrb, fixnum,  "eql?",     fix_eql,         MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
     1331  mrb_define_method(mrb, fixnum,  "hash",     flo_hash,        MRB_ARGS_NONE()); /* 15.2.8.3.18 */
     1332  mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
     1333  mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,        MRB_ARGS_NONE()); /* 15.2.8.3.25 */
     1334  mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,        MRB_ARGS_NONE());
     1335  mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
    11821336
    11831337  /* Float Class */
    11841338  mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric);                 /* 15.2.9 */
     1339  MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT);
    11851340  mrb_undef_class_method(mrb,  fl, "new");
    1186   mrb_define_method(mrb, fl,      "+",         flo_plus,         MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
    1187   mrb_define_method(mrb, fl,      "-",         flo_minus,        MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
    1188   mrb_define_method(mrb, fl,      "*",         flo_mul,          MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
    1189   mrb_define_method(mrb, fl,      "%",         flo_mod,          MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
    1190   mrb_define_method(mrb, fl,      "==",        flo_eq,           MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
    1191   mrb_define_method(mrb, fl,      "ceil",      flo_ceil,         MRB_ARGS_NONE()); /* 15.2.9.3.8  */
    1192   mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,     MRB_ARGS_NONE()); /* 15.2.9.3.9  */
    1193   mrb_define_method(mrb, fl,      "floor",     flo_floor,        MRB_ARGS_NONE()); /* 15.2.9.3.10 */
    1194   mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.11 */
    1195   mrb_define_method(mrb, fl,      "round",     flo_round,        MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */
    1196   mrb_define_method(mrb, fl,      "to_f",      flo_to_f,         MRB_ARGS_NONE()); /* 15.2.9.3.13 */
    1197   mrb_define_method(mrb, fl,      "to_i",      flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.14 */
    1198   mrb_define_method(mrb, fl,      "to_int",    flo_truncate,     MRB_ARGS_NONE());
    1199   mrb_define_method(mrb, fl,      "truncate",  flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.15 */
    1200   mrb_define_method(mrb, fl,      "divmod",    flo_divmod,       MRB_ARGS_REQ(1));
    1201   mrb_define_method(mrb, fl,      "eql?",      flo_eql,          MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
    1202 
    1203   mrb_define_method(mrb, fl,      "to_s",      flo_to_s,         MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
    1204   mrb_define_method(mrb, fl,      "inspect",   flo_to_s,         MRB_ARGS_NONE());
    1205   mrb_define_method(mrb, fl,      "nan?",      flo_nan_p,        MRB_ARGS_NONE());
     1341  mrb_define_method(mrb, fl,      "+",         flo_plus,       MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
     1342  mrb_define_method(mrb, fl,      "-",         flo_minus,      MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
     1343  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
     1344  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
     1345  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
     1346  mrb_define_method(mrb, fl,      "~",         flo_rev,        MRB_ARGS_NONE());
     1347  mrb_define_method(mrb, fl,      "&",         flo_and,        MRB_ARGS_REQ(1));
     1348  mrb_define_method(mrb, fl,      "|",         flo_or,         MRB_ARGS_REQ(1));
     1349  mrb_define_method(mrb, fl,      "^",         flo_xor,        MRB_ARGS_REQ(1));
     1350  mrb_define_method(mrb, fl,      ">>",        flo_lshift,     MRB_ARGS_REQ(1));
     1351  mrb_define_method(mrb, fl,      "<<",        flo_rshift,     MRB_ARGS_REQ(1));
     1352  mrb_define_method(mrb, fl,      "ceil",      flo_ceil,       MRB_ARGS_NONE()); /* 15.2.9.3.8  */
     1353  mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.9  */
     1354  mrb_define_method(mrb, fl,      "floor",     flo_floor,      MRB_ARGS_NONE()); /* 15.2.9.3.10 */
     1355  mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */
     1356  mrb_define_method(mrb, fl,      "round",     flo_round,      MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */
     1357  mrb_define_method(mrb, fl,      "to_f",      flo_to_f,       MRB_ARGS_NONE()); /* 15.2.9.3.13 */
     1358  mrb_define_method(mrb, fl,      "to_i",      flo_truncate,   MRB_ARGS_NONE()); /* 15.2.9.3.14 */
     1359  mrb_define_method(mrb, fl,      "to_int",    flo_truncate,   MRB_ARGS_NONE());
     1360  mrb_define_method(mrb, fl,      "truncate",  flo_truncate,   MRB_ARGS_NONE()); /* 15.2.9.3.15 */
     1361  mrb_define_method(mrb, fl,      "divmod",    flo_divmod,     MRB_ARGS_REQ(1));
     1362  mrb_define_method(mrb, fl,      "eql?",      flo_eql,        MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
     1363
     1364  mrb_define_method(mrb, fl,      "to_s",      flo_to_s,       MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
     1365  mrb_define_method(mrb, fl,      "inspect",   flo_to_s,       MRB_ARGS_NONE());
     1366  mrb_define_method(mrb, fl,      "nan?",      flo_nan_p,      MRB_ARGS_NONE());
    12061367
    12071368#ifdef INFINITY

  • EcnlProtoTool/trunk/mruby-1.3.0/src/object.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/class.h"
    9 #include "mruby/numeric.h"
    10 #include "mruby/string.h"
     7#include <mruby.h>
     8#include <mruby/class.h>
     9#include <mruby/numeric.h>
     10#include <mruby/string.h>
     11#include <mruby/class.h>
    1112
    1213MRB_API mrb_bool
    … …  
    266267
    267268  mrb->nil_class   = n = mrb_define_class(mrb, "NilClass",   mrb->object_class);
     269  MRB_SET_INSTANCE_TT(n, MRB_TT_TRUE);
    268270  mrb_undef_class_method(mrb, n, "new");
    269271  mrb_define_method(mrb, n, "&",    false_and,      MRB_ARGS_REQ(1));  /* 15.2.4.3.1  */
    … …  
    275277
    276278  mrb->true_class  = t = mrb_define_class(mrb, "TrueClass",  mrb->object_class);
     279  MRB_SET_INSTANCE_TT(t, MRB_TT_TRUE);
    277280  mrb_undef_class_method(mrb, t, "new");
    278281  mrb_define_method(mrb, t, "&",    true_and,       MRB_ARGS_REQ(1));  /* 15.2.5.3.1  */
    … …  
    283286
    284287  mrb->false_class = f = mrb_define_class(mrb, "FalseClass", mrb->object_class);
     288  MRB_SET_INSTANCE_TT(f, MRB_TT_TRUE);
    285289  mrb_undef_class_method(mrb, f, "new");
    286290  mrb_define_method(mrb, f, "&",    false_and,      MRB_ARGS_REQ(1));  /* 15.2.6.3.1  */
    … …  
    349353  mrb_value v;
    350354
    351   if (mrb_type(val) == type && type != MRB_TT_DATA) return val;
     355  if (mrb_type(val) == type && type != MRB_TT_DATA && type != MRB_TT_ISTRUCT) return val;
    352356  v = convert_type(mrb, val, tname, method, FALSE);
    353357  if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value();
    … …  
    381385/*    {MRB_TT_NODE,  "Node"}, */ /* internal use: syntax tree node */
    382386/*    {MRB_TT_UNDEF,  "undef"}, */ /* internal use: #undef; should not happen */
    383     {-1,  0}
     387  {MRB_TT_MAXDEFINE,  0}
    384388};
    385389
    … …  
    391395
    392396  xt = mrb_type(x);
    393   if ((xt != t) || (xt == MRB_TT_DATA)) {
     397  if ((xt != t) || (xt == MRB_TT_DATA) || (xt == MRB_TT_ISTRUCT)) {
    394398    while (type->type < MRB_TT_MAXDEFINE) {
    395399      if (type->type == t) {
    … …  
    441445  mrb_str_cat_cstr(mrb, str, cname);
    442446  mrb_str_cat_lit(mrb, str, ":");
    443   mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(obj)));
     447  mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_ptr(obj)));
    444448  mrb_str_cat_lit(mrb, str, ">");
    445449
    … …  
    482486    case MRB_TT_CLASS:
    483487    case MRB_TT_ICLASS:
     488    case MRB_TT_SCLASS:
    484489      break;
    485490
    … …  
    530535    case MRB_TT_FLOAT:
    531536      if (base != 0) goto arg_error;
    532       if (FIXABLE(mrb_float(val))) {
    533         break;
     537      else {
     538        mrb_float f = mrb_float(val);
     539        if (FIXABLE_FLOAT(f)) {
     540          break;
     541        }
    534542      }
    535543      return mrb_flo_to_fixnum(mrb, val);
    … …  
    549557    tmp = mrb_check_string_type(mrb, val);
    550558    if (!mrb_nil_p(tmp)) {
     559      val = tmp;
    551560      goto string_conv;
    552561    }

  • EcnlProtoTool/trunk/mruby-1.3.0/src/opcode.h

    r321 r331  
    11/* this header file is to be removed soon. */
    2 #include "mruby/opcode.h"
     2#include <mruby/opcode.h>

  • EcnlProtoTool/trunk/mruby-1.3.0/src/pool.c

    r321 r331  
    88#include <stdint.h>
    99#include <string.h>
    10 #include "mruby.h"
     10#include <mruby.h>
    1111
    1212/* configuration section */
    … …  
    1414/* or undef it if alignment does not matter */
    1515#ifndef POOL_ALIGNMENT
     16#if INTPTR_MAX == INT64_MAX
     17#define POOL_ALIGNMENT 8
     18#else
    1619#define POOL_ALIGNMENT 4
     20#endif
    1721#endif
    1822/* page size of memory pool */

  • EcnlProtoTool/trunk/mruby-1.3.0/src/print.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/string.h"
    9 #include "mruby/variable.h"
     7#include <mruby.h>
     8#include <mruby/string.h>
     9#include <mruby/variable.h>
    1010
    1111#ifndef MRB_DISABLE_STDIO

  • EcnlProtoTool/trunk/mruby-1.3.0/src/proc.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/class.h"
    9 #include "mruby/proc.h"
    10 #include "mruby/opcode.h"
     7#include <mruby.h>
     8#include <mruby/class.h>
     9#include <mruby/proc.h>
     10#include <mruby/opcode.h>
    1111
    1212static mrb_code call_iseq[] = {
    … …  
    4242  e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, (struct RClass*)mrb->c->ci->proc->env);
    4343  MRB_SET_ENV_STACK_LEN(e, nlocals);
    44   e->mid = mrb->c->ci->mid;
     44  e->cxt.c = mrb->c;
    4545  e->cioff = mrb->c->ci - mrb->c->cibase;
    4646  e->stack = mrb->c->stack;
    … …  
    6262  }
    6363  p->env = e;
     64  mrb_field_write_barrier(mrb, (struct RBasic *)p, (struct RBasic *)p->env);
    6465}
    6566
    … …  
    136137}
    137138
    138 MRB_API void
     139void
    139140mrb_proc_copy(struct RProc *a, struct RProc *b)
    140141{
    141142  a->flags = b->flags;
    142143  a->body = b->body;
    143   if (!MRB_PROC_CFUNC_P(a)) {
     144  if (!MRB_PROC_CFUNC_P(a) && a->body.irep) {
    144145    a->body.irep->refcnt++;
    145146  }
    … …  
    149150
    150151static mrb_value
    151 mrb_proc_initialize(mrb_state *mrb, mrb_value self)
     152mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class)
    152153{
    153154  mrb_value blk;
     155  mrb_value proc;
     156  struct RProc *p;
    154157
    155158  mrb_get_args(mrb, "&", &blk);
    … …  
    158161    mrb_raise(mrb, E_ARGUMENT_ERROR, "tried to create Proc object without a block");
    159162  }
    160   else {
    161     mrb_proc_copy(mrb_proc_ptr(self), mrb_proc_ptr(blk));
    162   }
    163   return self;
     163  p = (struct RProc *)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class));
     164  mrb_proc_copy(p, mrb_proc_ptr(blk));
     165  proc = mrb_obj_value(p);
     166  mrb_funcall_with_block(mrb, proc, mrb_intern_lit(mrb, "initialize"), 0, NULL, blk);
     167  return proc;
    164168}
    165169
    … …  
    189193}
    190194
    191 mrb_code*
    192 mrb_proc_iseq(mrb_state *mrb, struct RProc *p)
    193 {
    194   return p->body.irep->iseq;
    195 }
    196 
    197195/* 15.2.17.4.2 */
    198196static mrb_value
    … …  
    200198{
    201199  struct RProc *p = mrb_proc_ptr(self);
    202   mrb_code *iseq = mrb_proc_iseq(mrb, p);
     200  struct mrb_irep *irep;
     201  mrb_code *iseq;
    203202  mrb_aspec aspec;
    204203  int ma, op, ra, pa, arity;
    … …  
    209208  }
    210209
     210  irep = p->body.irep;
     211  if (!irep) {
     212    return mrb_fixnum_value(0);
     213  }
     214
     215  iseq = irep->iseq;
    211216  /* arity is depend on OP_ENTER */
    212217  if (GET_OPCODE(*iseq) != OP_ENTER) {
    … …  
    267272  call_irep->iseq = call_iseq;
    268273  call_irep->ilen = 1;
    269 
    270   mrb_define_method(mrb, mrb->proc_class, "initialize", mrb_proc_initialize, MRB_ARGS_NONE());
     274  call_irep->nregs = 2;         /* receiver and block */
     275
     276  mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_ANY());
    271277  mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1));
    272278  mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE());

  • EcnlProtoTool/trunk/mruby-1.3.0/src/range.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/class.h"
    9 #include "mruby/range.h"
    10 #include "mruby/string.h"
    11 #include "mruby/array.h"
     7#include <mruby.h>
     8#include <mruby/class.h>
     9#include <mruby/range.h>
     10#include <mruby/string.h>
     11#include <mruby/array.h>
    1212
    1313#define RANGE_CLASS (mrb_class_get(mrb, "Range"))
     14
     15MRB_API struct RRange*
     16mrb_range_ptr(mrb_state *mrb, mrb_value v)
     17{
     18  struct RRange *r = (struct RRange*)mrb_ptr(v);
     19
     20  if (r->edges == NULL) {
     21    mrb_raise(mrb, E_ARGUMENT_ERROR, "uninitialized range");
     22  }
     23  return r;
     24}
    1425
    1526static void
    … …  
    5869mrb_range_beg(mrb_state *mrb, mrb_value range)
    5970{
    60   struct RRange *r = mrb_range_ptr(range);
     71  struct RRange *r = mrb_range_ptr(mrb, range);
    6172
    6273  return r->edges->beg;
    … …  
    7788mrb_range_end(mrb_state *mrb, mrb_value range)
    7889{
    79   struct RRange *r = mrb_range_ptr(range);
     90  struct RRange *r = mrb_range_ptr(mrb, range);
    8091
    8192  return r->edges->end;
    … …  
    91102mrb_range_excl(mrb_state *mrb, mrb_value range)
    92103{
    93   struct RRange *r = mrb_range_ptr(range);
     104  struct RRange *r = mrb_range_ptr(mrb, range);
    94105
    95106  return mrb_bool_value(r->excl);
    … …  
    99110range_init(mrb_state *mrb, mrb_value range, mrb_value beg, mrb_value end, mrb_bool exclude_end)
    100111{
    101   struct RRange *r = mrb_range_ptr(range);
     112  struct RRange *r = mrb_range_raw_ptr(range);
    102113
    103114  range_check(mrb, beg, end);
    … …  
    130141  }
    131142  /* Ranges are immutable, so that they should be initialized only once. */
     143  if (mrb_range_raw_ptr(range)->edges) {
     144    mrb_name_error(mrb, mrb_intern_lit(mrb, "initialize"), "`initialize' called twice");
     145  }
    132146  range_init(mrb, range, beg, end, exclusive);
    133147  return range;
    … …  
    153167  struct RRange *rr;
    154168  struct RRange *ro;
    155   mrb_value obj;
     169  mrb_value obj, v1, v2;
    156170
    157171  mrb_get_args(mrb, "o", &obj);
    … …  
    162176  }
    163177
    164   rr = mrb_range_ptr(range);
    165   ro = mrb_range_ptr(obj);
    166   if (!mrb_bool(mrb_funcall(mrb, rr->edges->beg, "==", 1, ro->edges->beg)) ||
    167       !mrb_bool(mrb_funcall(mrb, rr->edges->end, "==", 1, ro->edges->end)) ||
    168       rr->excl != ro->excl) {
     178  rr = mrb_range_ptr(mrb, range);
     179  ro = mrb_range_ptr(mrb, obj);
     180  v1 = mrb_funcall(mrb, rr->edges->beg, "==", 1, ro->edges->beg);
     181  v2 = mrb_funcall(mrb, rr->edges->end, "==", 1, ro->edges->end);
     182  if (!mrb_bool(v1) || !mrb_bool(v2) || rr->excl != ro->excl) {
    169183    return mrb_false_value();
    170184  }
    … …  
    220234{
    221235  mrb_value val;
    222   struct RRange *r = mrb_range_ptr(range);
     236  struct RRange *r = mrb_range_ptr(mrb, range);
    223237  mrb_value beg, end;
    224238  mrb_bool include_p;
    … …  
    228242  beg = r->edges->beg;
    229243  end = r->edges->end;
    230   include_p = r_le(mrb, beg, val) && /* beg <= val */
    231               ((r->excl && r_gt(mrb, end, val)) || /* end >  val */
    232               (r_ge(mrb, end, val))); /* end >= val */
     244  include_p = r_le(mrb, beg, val) &&           /* beg <= val */
     245              (r->excl ? r_gt(mrb, end, val)  /* end >  val */
     246                       : r_ge(mrb, end, val)); /* end >= val */
    233247
    234248  return mrb_bool_value(include_p);
    235249}
    236250
    237 static mrb_bool
    238 range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc)
     251MRB_API mrb_int
     252mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc)
    239253{
    240254  mrb_int beg, end;
    241   struct RRange *r = mrb_range_ptr(range);
    242 
    243   if (mrb_type(range) != MRB_TT_RANGE) return FALSE;
     255  struct RRange *r;
     256
     257  if (mrb_type(range) != MRB_TT_RANGE) return 0;
     258  r = mrb_range_ptr(mrb, range);
    244259
    245260  beg = mrb_int(mrb, r->edges->beg);
    … …  
    248263  if (beg < 0) {
    249264    beg += len;
    250     if (beg < 0) return FALSE;
     265    if (beg < 0) return 2;
    251266  }
    252267
    253268  if (trunc) {
    254     if (beg > len) return FALSE;
     269    if (beg > len) return 2;
    255270    if (end > len) end = len;
    256271  }
    … …  
    264279  *begp = beg;
    265280  *lenp = len;
    266   return TRUE;
    267 }
    268 
    269 MRB_API mrb_bool
    270 mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len)
    271 {
    272   return range_beg_len(mrb, range, begp, lenp, len, TRUE);
     281  return 1;
    273282}
    274283
    … …  
    285294{
    286295  mrb_value str, str2;
    287   struct RRange *r = mrb_range_ptr(range);
     296  struct RRange *r = mrb_range_ptr(mrb, range);
    288297
    289298  str  = mrb_obj_as_string(mrb, r->edges->beg);
    … …  
    310319{
    311320  mrb_value str, str2;
    312   struct RRange *r = mrb_range_ptr(range);
     321  struct RRange *r = mrb_range_ptr(mrb, range);
    313322
    314323  str  = mrb_inspect(mrb, r->edges->beg);
    … …  
    350359  if (mrb_type(obj) != MRB_TT_RANGE) return mrb_false_value();
    351360
    352   r = mrb_range_ptr(range);
    353   o = mrb_range_ptr(obj);
     361  r = mrb_range_ptr(mrb, range);
     362  o = mrb_range_ptr(mrb, obj);
    354363  if (!mrb_eql(mrb, r->edges->beg, o->edges->beg) ||
    355364      !mrb_eql(mrb, r->edges->end, o->edges->end) ||
    … …  
    374383  }
    375384
    376   r = mrb_range_ptr(src);
     385  r = mrb_range_ptr(mrb, src);
    377386  range_init(mrb, copy, r->edges->beg, r->edges->end, r->excl);
    378387
    … …  
    391400      mrb_ary_push(mrb, result, func(mrb, obj, mrb_fixnum(argv[i])));
    392401    }
    393     else if (range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE)) {
     402    else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == 1) {
    394403      mrb_int const end = olen < beg + len ? olen : beg + len;
    395404      for (j = beg; j < end; ++j) {

  • EcnlProtoTool/trunk/mruby-1.3.0/src/state.c

    r321 r331  
    77#include <stdlib.h>
    88#include <string.h>
    9 #include "mruby.h"
    10 #include "mruby/irep.h"
    11 #include "mruby/variable.h"
    12 #include "mruby/debug.h"
    13 #include "mruby/string.h"
     9#include <mruby.h>
     10#include <mruby/irep.h>
     11#include <mruby/variable.h>
     12#include <mruby/debug.h>
     13#include <mruby/string.h>
    1414
    1515void mrb_init_core(mrb_state*);
    … …  
    142142  if (!(irep->flags & MRB_ISEQ_NO_FREE))
    143143    mrb_free(mrb, irep->iseq);
    144   for (i=0; i<irep->plen; i++) {
     144  if (irep->pool) for (i=0; i<irep->plen; i++) {
    145145    if (mrb_type(irep->pool[i]) == MRB_TT_STRING) {
    146146      mrb_gc_free_str(mrb, RSTRING(irep->pool[i]));
    … …  
    160160  mrb_free(mrb, irep->reps);
    161161  mrb_free(mrb, irep->lv);
    162   mrb_free(mrb, (void *)irep->filename);
     162  if (irep->own_filename) {
     163    mrb_free(mrb, (void *)irep->filename);
     164  }
    163165  mrb_free(mrb, irep->lines);
    164166  mrb_debug_info_free(mrb, irep->debug_info);
    … …  
    216218}
    217219
     220void mrb_free_backtrace(mrb_state *mrb);
     221
    218222MRB_API void
    219223mrb_free_context(mrb_state *mrb, struct mrb_context *c)
    … …  
    259263  *irep = mrb_irep_zero;
    260264  irep->refcnt = 1;
     265  irep->own_filename = FALSE;
    261266
    262267  return irep;
    … …  
    287292  if (mrb->atexit_stack_len == 0) {
    288293    mrb->atexit_stack = (mrb_atexit_func*)mrb_malloc(mrb, stack_size);
    289   } else {
     294  }
     295  else {
    290296    mrb->atexit_stack = (mrb_atexit_func*)mrb_realloc(mrb, mrb->atexit_stack, stack_size);
    291297  }

  • EcnlProtoTool/trunk/mruby-1.3.0/src/string.c

    r321 r331  
    44** See Copyright Notice in mruby.h
    55*/
     6
     7#ifdef _MSC_VER
     8# define _CRT_NONSTDC_NO_DEPRECATE
     9#endif
    610
    711#include <float.h>
    … …  
    1014#include <stdlib.h>
    1115#include <string.h>
    12 #include "mruby.h"
    13 #include "mruby/array.h"
    14 #include "mruby/class.h"
    15 #include "mruby/range.h"
    16 #include "mruby/string.h"
    17 #include "mruby/re.h"
     16#include <mruby.h>
     17#include <mruby/array.h>
     18#include <mruby/class.h>
     19#include <mruby/range.h>
     20#include <mruby/string.h>
     21#include <mruby/re.h>
    1822
    1923typedef struct mrb_shared_string {
    … …  
    6064      memcpy(s->as.ary, p, len);
    6165    }
    62   } else {
     66  }
     67  else {
    6368    if (len >= MRB_INT_MAX) {
    6469      mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
    … …  
    115120}
    116121
    117 static inline void
    118 resize_capa(mrb_state *mrb, struct RString *s, mrb_int capacity)
    119 {
     122static void
     123resize_capa(mrb_state *mrb, struct RString *s, size_t capacity)
     124{
     125#if SIZE_MAX > MRB_INT_MAX
     126    mrb_assert(capacity < MRB_INT_MAX);
     127#endif
    120128  if (RSTR_EMBED_P(s)) {
    121129    if (RSTRING_EMBED_LEN_MAX < capacity) {
    … …  
    126134      s->as.heap.ptr = tmp;
    127135      s->as.heap.len = len;
    128       s->as.heap.aux.capa = capacity;
     136      s->as.heap.aux.capa = (mrb_int)capacity;
    129137    }
    130138  }
    131139  else {
    132     s->as.heap.ptr = (char *)mrb_realloc(mrb, RSTR_PTR(s), capacity+1);
    133     s->as.heap.aux.capa = capacity;
     140    s->as.heap.ptr = (char*)mrb_realloc(mrb, RSTR_PTR(s), capacity+1);
     141    s->as.heap.aux.capa = (mrb_int)capacity;
    134142  }
    135143}
    … …  
    148156  }
    149157
    150   if (RSTR_EMBED_P(s))
    151     capa = RSTRING_EMBED_LEN_MAX;
    152   else
    153     capa = s->as.heap.aux.capa;
    154 
    155   if (RSTR_LEN(s) >= MRB_INT_MAX - (mrb_int)len) {
     158  capa = RSTR_CAPA(s);
     159  if (capa <= RSTRING_EMBED_LEN_MAX)
     160    capa = RSTRING_EMBED_LEN_MAX+1;
     161
     162  total = RSTR_LEN(s)+len;
     163  if (total >= MRB_INT_MAX) {
     164  size_error:
    156165    mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
    157166  }
    158   total = RSTR_LEN(s)+len;
    159167  if (capa <= total) {
    160168    while (total > capa) {
    161       if (capa + 1 >= MRB_INT_MAX / 2) {
    162         capa = (total + 4095) / 4096;
    163         break;
    164       }
    165       capa = (capa + 1) * 2;
     169      if (capa <= MRB_INT_MAX / 2) {
     170        capa *= 2;
     171      }
     172      else {
     173        capa = total;
     174      }
     175    }
     176    if (capa < total || capa > MRB_INT_MAX) {
     177      goto size_error;
    166178    }
    167179    resize_capa(mrb, s, capa);
    … …  
    270282  char* p = RSTRING_PTR(str);
    271283  char* e = p;
     284  if (RSTRING(str)->flags & MRB_STR_NO_UTF) {
     285    return RSTRING_LEN(str);
     286  }
    272287  e += len < 0 ? RSTRING_LEN(str) : len;
    273288  while (p<e) {
    … …  
    275290    total++;
    276291  }
     292  if (RSTRING_LEN(str) == total) {
     293    RSTRING(str)->flags |= MRB_STR_NO_UTF;
     294  }
    277295  return total;
    278296}
    … …  
    303321
    304322  for (b=i=0; b<bi; i++) {
    305     n = utf8len(p, p+bi);
     323    n = utf8len_codepage[(unsigned char)*p];
    306324    b += n;
    307325    p += n;
    308326  }
     327  if (b != bi) return -1;
    309328  return i;
    310329}
    311330
     331#define BYTES_ALIGN_CHECK(pos) if (pos < 0) return mrb_nil_value();
    312332#else
    313333#define RSTRING_CHAR_LEN(s) RSTRING_LEN(s)
    314334#define chars2bytes(p, off, ci) (ci)
    315335#define bytes2chars(p, bi) (bi)
     336#define BYTES_ALIGN_CHECK(pos)
    316337#endif
    317338
    … …  
    349370  }
    350371  else if (m == 1) {
    351     const unsigned char *ys = y, *ye = ys + n;
    352     for (; y < ye; ++y) {
    353       if (*x == *y)
    354         return y - ys;
    355     }
    356     return -1;
     372    const unsigned char *ys = (const unsigned char *)memchr(y, *x, n);
     373
     374    if (ys)
     375      return ys - y;
     376    else
     377      return -1;
    357378  }
    358379  return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n);
    … …  
    404425
    405426  orig = mrb_str_ptr(str);
    406   if (RSTR_EMBED_P(orig)) {
     427  if (RSTR_EMBED_P(orig) || RSTR_LEN(orig) == 0) {
    407428    s = str_new(mrb, orig->as.ary+beg, len);
    408429  }
    … …  
    450471    if (beg < 0) return mrb_nil_value();
    451472  }
    452   if (beg + len > clen)
     473  if (len > clen - beg)
    453474    len = clen - beg;
    454475  if (len <= 0) {
    … …  
    489510check_frozen(mrb_state *mrb, struct RString *s)
    490511{
    491   if (RSTR_FROZEN_P(s)) {
     512  if (MRB_FROZEN_P(s)) {
    492513    mrb_raise(mrb, E_RUNTIME_ERROR, "can't modify frozen string");
    493514  }
    … …  
    500521
    501522  check_frozen(mrb, s1);
     523  if (s1 == s2) return mrb_obj_value(s1);
     524  s1->flags &= ~MRB_STR_NO_UTF;
     525  s1->flags |= s2->flags&MRB_STR_NO_UTF;
    502526  len = RSTR_LEN(s2);
    503527  if (RSTR_SHARED_P(s1)) {
    … …  
    646670{
    647671  check_frozen(mrb, s);
     672  s->flags &= ~MRB_STR_NO_UTF;
    648673  if (RSTR_SHARED_P(s)) {
    649674    mrb_shared_string *shared = s->as.heap.aux.shared;
    650675
    651     if (shared->refcnt == 1 && s->as.heap.ptr == shared->ptr) {
     676    if (shared->nofree == 0 && shared->refcnt == 1 && s->as.heap.ptr == shared->ptr) {
    652677      s->as.heap.ptr = shared->ptr;
    653678      s->as.heap.aux.capa = shared->len;
    … …  
    661686      p = RSTR_PTR(s);
    662687      len = s->as.heap.len;
    663       ptr = (char *)mrb_malloc(mrb, (size_t)len + 1);
     688      if (len < RSTRING_EMBED_LEN_MAX) {
     689        RSTR_SET_EMBED_FLAG(s);
     690        RSTR_SET_EMBED_LEN(s, len);
     691        ptr = RSTR_PTR(s);
     692      }
     693      else {
     694        ptr = (char *)mrb_malloc(mrb, (size_t)len + 1);
     695        s->as.heap.ptr = ptr;
     696        s->as.heap.aux.capa = len;
     697      }
    664698      if (p) {
    665699        memcpy(ptr, p, len);
    666700      }
    667701      ptr[len] = '\0';
    668       s->as.heap.ptr = ptr;
    669       s->as.heap.aux.capa = len;
    670702      str_decref(mrb, shared);
    671703    }
    … …  
    675707  if (RSTR_NOFREE_P(s)) {
    676708    char *p = s->as.heap.ptr;
    677 
    678     s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)s->as.heap.len+1);
     709    mrb_int len = s->as.heap.len;
     710
     711    RSTR_UNSET_NOFREE_FLAG(s);
     712    if (len < RSTRING_EMBED_LEN_MAX) {
     713      RSTR_SET_EMBED_FLAG(s);
     714      RSTR_SET_EMBED_LEN(s, len);
     715    }
     716    else {
     717      s->as.heap.ptr = (char *)mrb_malloc(mrb, (size_t)len+1);
     718      s->as.heap.aux.capa = len;
     719    }
    679720    if (p) {
    680       memcpy(RSTR_PTR(s), p, s->as.heap.len);
    681     }
    682     RSTR_PTR(s)[s->as.heap.len] = '\0';
    683     s->as.heap.aux.capa = s->as.heap.len;
    684     RSTR_UNSET_NOFREE_FLAG(s);
     721      memcpy(RSTR_PTR(s), p, len);
     722    }
     723    RSTR_PTR(s)[len] = '\0';
    685724    return;
    686725  }
    687 }
    688 
    689 static mrb_value
    690 mrb_str_freeze(mrb_state *mrb, mrb_value str)
    691 {
    692   struct RString *s = mrb_str_ptr(str);
    693 
    694   RSTR_SET_FROZEN_FLAG(s);
    695   return str;
    696726}
    697727
    … …  
    747777  }
    748778  s2 = mrb_str_ptr(other);
     779  if (RSTR_LEN(s2) == 0) {
     780    return;
     781  }
    749782  len = RSTR_LEN(s1) + RSTR_LEN(s2);
    750783
     784  if (len < 0 || len >= MRB_INT_MAX) {
     785    mrb_raise(mrb, E_ARGUMENT_ERROR, "string size too big");
     786  }
    751787  if (RSTRING_CAPA(self) < len) {
    752788    resize_capa(mrb, s1, len);
    … …  
    932968      mrb_value tmp = mrb_funcall(mrb, str2, "<=>", 1, str1);
    933969
    934       if (mrb_nil_p(tmp)) return mrb_nil_value();
    935       if (!mrb_fixnum(tmp)) {
     970      if (!mrb_nil_p(tmp)) return mrb_nil_value();
     971      if (!mrb_fixnum_p(tmp)) {
    936972        return mrb_funcall(mrb, mrb_fixnum_value(0), "-", 1, tmp);
    937973      }
    … …  
    10141050}
    10151051
     1052MRB_API mrb_int
     1053mrb_string_value_len(mrb_state *mrb, mrb_value ptr)
     1054{
     1055  mrb_value str = mrb_str_to_str(mrb, ptr);
     1056  return RSTRING_LEN(str);
     1057}
     1058
    10161059void
    10171060mrb_noregexp(mrb_state *mrb, mrb_value self)
    … …  
    10591102
    10601103    case MRB_TT_RANGE:
    1061       /* check if indx is Range */
    1062       {
    1063         mrb_int beg, len;
    1064 
    1065         len = RSTRING_CHAR_LEN(str);
    1066         if (mrb_range_beg_len(mrb, indx, &beg, &len, len)) {
    1067           return str_subseq(mrb, str, beg, len);
    1068         }
    1069         else {
    1070           return mrb_nil_value();
    1071         }
    1072       }
    1073     case MRB_TT_FLOAT:
     1104      goto range_arg;
     1105
    10741106    default:
    10751107      indx = mrb_Integer(mrb, indx);
    10761108      if (mrb_nil_p(indx)) {
     1109      range_arg:
     1110        {
     1111          mrb_int beg, len;
     1112
     1113          len = RSTRING_CHAR_LEN(str);
     1114          switch (mrb_range_beg_len(mrb, indx, &beg, &len, len, TRUE)) {
     1115          case 1:
     1116            return str_subseq(mrb, str, beg, len);
     1117          case 2:
     1118            return mrb_nil_value();
     1119          default:
     1120            break;
     1121          }
     1122        }
    10771123        mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Fixnum");
    10781124      }
    … …  
    11311177  argc = mrb_get_args(mrb, "o|o", &a1, &a2);
    11321178  if (argc == 2) {
     1179    mrb_int n1, n2;
     1180
    11331181    mrb_regexp_check(mrb, a1);
    1134     return str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));
     1182    mrb_get_args(mrb, "ii", &n1, &n2);
     1183    return str_substr(mrb, str, n1, n2);
    11351184  }
    11361185  if (argc != 1) {
    … …  
    12151264  mrb_int rslen;
    12161265  mrb_int len;
     1266  mrb_int argc;
    12171267  struct RString *s = mrb_str_ptr(str);
    12181268
    12191269  mrb_str_modify(mrb, s);
     1270  argc = mrb_get_args(mrb, "|S", &rs);
    12201271  len = RSTR_LEN(s);
    1221   if (mrb_get_args(mrb, "|S", &rs) == 0) {
     1272  if (argc == 0) {
    12221273    if (len == 0) return mrb_nil_value();
    12231274  smart_chomp:
    … …  
    15101561mrb_str_include(mrb_state *mrb, mrb_value self)
    15111562{
    1512   mrb_int i;
    15131563  mrb_value str2;
    1514   mrb_bool include_p;
    1515 
    1516   mrb_get_args(mrb, "o", &str2);
    1517   if (mrb_fixnum_p(str2)) {
    1518     include_p = (memchr(RSTRING_PTR(self), mrb_fixnum(str2), RSTRING_LEN(self)) != NULL);
    1519   }
    1520   else {
    1521     str2 = mrb_str_to_str(mrb, str2);
    1522     i = str_index(mrb, self, str2, 0);
    1523 
    1524     include_p = (i != -1);
    1525   }
    1526 
    1527   return mrb_bool_value(include_p);
     1564
     1565  mrb_get_args(mrb, "S", &str2);
     1566  if (str_index(mrb, self, str2, 0) < 0)
     1567    return mrb_bool_value(FALSE);
     1568  return mrb_bool_value(TRUE);
    15281569}
    15291570
    … …  
    15591600  mrb_get_args(mrb, "*", &argv, &argc);
    15601601  if (argc == 2) {
    1561     pos = mrb_fixnum(argv[1]);
    1562     sub = argv[0];
     1602    mrb_get_args(mrb, "oi", &sub, &pos);
    15631603  }
    15641604  else {
    … …  
    15771617    }
    15781618  }
    1579   if (pos >= clen) return mrb_nil_value();
     1619  if (pos > clen) return mrb_nil_value();
    15801620  pos = chars2bytes(str, 0, pos);
    15811621
    … …  
    15981638  if (pos == -1) return mrb_nil_value();
    15991639  pos = bytes2chars(RSTRING_PTR(str), pos);
     1640  BYTES_ALIGN_CHECK(pos);
    16001641  return mrb_fixnum_value(pos);
    16011642}
    … …  
    16331674  mrb_value str2;
    16341675
    1635   if (mrb_get_args(mrb, "|S", &str2) == 1) {
    1636     str_replace(mrb, mrb_str_ptr(self), mrb_str_ptr(str2));
    1637   }
     1676  if (mrb_get_args(mrb, "|S", &str2) == 0) {
     1677    struct RString *s = str_new(mrb, 0, 0);
     1678    str2 = mrb_obj_value(s);
     1679  }
     1680  str_replace(mrb, mrb_str_ptr(self), mrb_str_ptr(str2));
    16381681  return self;
    16391682}
    … …  
    17431786    mrb_str_modify(mrb, mrb_str_ptr(str));
    17441787    len = RSTRING_LEN(str);
    1745     buf = mrb_malloc(mrb, (size_t)len);
     1788    buf = (char*)mrb_malloc(mrb, (size_t)len);
    17461789    p = buf;
    17471790    e = buf + len;
    … …  
    18241867  mrb_int argc;
    18251868  mrb_value sub;
    1826   mrb_value vpos;
    18271869  mrb_int pos, len = RSTRING_CHAR_LEN(str);
    18281870
    18291871  mrb_get_args(mrb, "*", &argv, &argc);
    18301872  if (argc == 2) {
    1831     sub = argv[0];
    1832     vpos = argv[1];
    1833     pos = mrb_fixnum(vpos);
     1873    mrb_get_args(mrb, "oi", &sub, &pos);
    18341874    if (pos < 0) {
    18351875      pos += len;
    … …  
    18491889  }
    18501890  pos = chars2bytes(str, 0, pos);
    1851   len = chars2bytes(str, pos, len);
    18521891  mrb_regexp_check(mrb, sub);
    18531892
    … …  
    18671906      if (pos >= 0) {
    18681907        pos = bytes2chars(RSTRING_PTR(str), pos);
     1908        BYTES_ALIGN_CHECK(pos);
    18691909        return mrb_fixnum_value(pos);
    18701910      }
    … …  
    19221962  mrb_value spat = mrb_nil_value();
    19231963  enum {awk, string, regexp} split_type = string;
    1924   long i = 0, lim_p;
     1964  mrb_int i = 0;
    19251965  mrb_int beg;
    19261966  mrb_int end;
    19271967  mrb_int lim = 0;
     1968  mrb_bool lim_p;
    19281969  mrb_value result, tmp;
    19291970
    … …  
    19982039        end = mrb_memsearch(RSTRING_PTR(spat), pat_len, RSTRING_PTR(str)+idx, str_len - idx);
    19992040        if (end < 0) break;
    2000       } else {
     2041      }
     2042      else {
    20012043        end = chars2bytes(str, idx, 1);
    20022044      }
    … …  
    20312073
    20322074MRB_API mrb_value
    2033 mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
    2034 {
    2035   const char *p;
     2075mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, int base, int badcheck)
     2076{
     2077  const char *p = str;
     2078  const char *pend = str + len;
    20362079  char sign = 1;
    2037   int c, uscore;
     2080  int c;
    20382081  uint64_t n = 0;
    20392082  mrb_int val;
    … …  
    20452088     -1)
    20462089
    2047   if (!str) {
     2090  if (!p) {
    20482091    if (badcheck) goto bad;
    20492092    return mrb_fixnum_value(0);
    20502093  }
    2051   while (ISSPACE(*str)) str++;
    2052 
    2053   if (str[0] == '+') {
    2054     str++;
    2055   }
    2056   else if (str[0] == '-') {
    2057     str++;
     2094  while (p<pend && ISSPACE(*p))
     2095    p++;
     2096
     2097  if (p[0] == '+') {
     2098    p++;
     2099  }
     2100  else if (p[0] == '-') {
     2101    p++;
    20582102    sign = 0;
    20592103  }
    2060   if (str[0] == '+' || str[0] == '-') {
    2061     if (badcheck) goto bad;
    2062     return mrb_fixnum_value(0);
    2063   }
    20642104  if (base <= 0) {
    2065     if (str[0] == '0') {
    2066       switch (str[1]) {
     2105    if (p[0] == '0') {
     2106      switch (p[1]) {
    20672107        case 'x': case 'X':
    20682108          base = 16;
    … …  
    20792119        default:
    20802120          base = 8;
     2121          break;
    20812122      }
    20822123    }
    … …  
    20902131  switch (base) {
    20912132    case 2:
    2092       if (str[0] == '0' && (str[1] == 'b'||str[1] == 'B')) {
    2093         str += 2;
     2133      if (p[0] == '0' && (p[1] == 'b'||p[1] == 'B')) {
     2134        p += 2;
    20942135      }
    20952136      break;
    … …  
    20972138      break;
    20982139    case 8:
    2099       if (str[0] == '0' && (str[1] == 'o'||str[1] == 'O')) {
    2100         str += 2;
     2140      if (p[0] == '0' && (p[1] == 'o'||p[1] == 'O')) {
     2141        p += 2;
    21012142      }
    21022143    case 4: case 5: case 6: case 7:
    21032144      break;
    21042145    case 10:
    2105       if (str[0] == '0' && (str[1] == 'd'||str[1] == 'D')) {
    2106         str += 2;
     2146      if (p[0] == '0' && (p[1] == 'd'||p[1] == 'D')) {
     2147        p += 2;
    21072148      }
    21082149    case 9: case 11: case 12: case 13: case 14: case 15:
    21092150      break;
    21102151    case 16:
    2111       if (str[0] == '0' && (str[1] == 'x'||str[1] == 'X')) {
    2112         str += 2;
     2152      if (p[0] == '0' && (p[1] == 'x'||p[1] == 'X')) {
     2153        p += 2;
    21132154      }
    21142155      break;
    … …  
    21192160      break;
    21202161  } /* end of switch (base) { */
    2121   if (*str == '0') {    /* squeeze preceding 0s */
    2122     uscore = 0;
    2123     while ((c = *++str) == '0' || c == '_') {
    2124       if (c == '_') {
    2125         if (++uscore >= 2)
    2126           break;
    2127       }
    2128       else
    2129         uscore = 0;
    2130     }
    2131     if (!(c = *str) || ISSPACE(c)) --str;
    2132   }
    2133   c = *str;
    2134   c = conv_digit(c);
    2135   if (c < 0 || c >= base) {
     2162  if (p>=pend) {
    21362163    if (badcheck) goto bad;
    21372164    return mrb_fixnum_value(0);
    21382165  }
    2139 
    2140   uscore = 0;
    2141   for (p=str;*p;p++) {
     2166  if (*p == '0') {    /* squeeze preceding 0s */
     2167    p++;
     2168    while (p<pend) {
     2169      c = *p++;
     2170      if (c == '_') {
     2171        if (p<pend && *p == '_') {
     2172          if (badcheck) goto bad;
     2173          break;
     2174        }
     2175        continue;
     2176      }
     2177      if (c != '0') {
     2178        p--;
     2179        break;
     2180      }
     2181    }
     2182    if (*(p - 1) == '0')
     2183      p--;
     2184  }
     2185  if (p == pend) {
     2186    if (badcheck) goto bad;
     2187    return mrb_fixnum_value(0);
     2188  }
     2189  for ( ;p<pend;p++) {
    21422190    if (*p == '_') {
    2143       if (uscore == 0) {
    2144         uscore++;
     2191      p++;
     2192      if (p==pend) {
     2193        if (badcheck) goto bad;
    21452194        continue;
    21462195      }
    2147       if (badcheck) goto bad;
    2148       break;
    2149     }
    2150     uscore = 0;
     2196      if (*p == '_') {
     2197        if (badcheck) goto bad;
     2198        break;
     2199      }
     2200    }
     2201    if (badcheck && *p == '\0') {
     2202      goto nullbyte;
     2203    }
    21512204    c = conv_digit(*p);
    21522205    if (c < 0 || c >= base) {
    2153       if (badcheck) goto bad;
    21542206      break;
    21552207    }
    21562208    n *= base;
    21572209    n += c;
    2158     if (n > MRB_INT_MAX) {
    2159       mrb_raisef(mrb, E_ARGUMENT_ERROR, "string (%S) too big for integer", mrb_str_new_cstr(mrb, str));
    2160     }
    2161   }
    2162   val = n;
     2210    if (n > (uint64_t)MRB_INT_MAX + (sign ? 0 : 1)) {
     2211      mrb_raisef(mrb, E_ARGUMENT_ERROR, "string (%S) too big for integer",
     2212                 mrb_str_new(mrb, str, pend-str));
     2213    }
     2214  }
     2215  val = (mrb_int)n;
    21632216  if (badcheck) {
    21642217    if (p == str) goto bad; /* no number */
    2165     while (*p && ISSPACE(*p)) p++;
    2166     if (*p) goto bad;           /* trailing garbage */
     2218    while (p<pend && ISSPACE(*p)) p++;
     2219    if (p<pend) goto bad;       /* trailing garbage */
    21672220  }
    21682221
    21692222  return mrb_fixnum_value(sign ? val : -val);
    2170 bad:
    2171   mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for number(%S)", mrb_str_new_cstr(mrb, str));
     2223 nullbyte:
     2224  mrb_raise(mrb, E_ARGUMENT_ERROR, "string contains null byte");
     2225  /* not reached */
     2226 bad:
     2227  mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid string for number(%S)",
     2228             mrb_inspect(mrb, mrb_str_new(mrb, str, pend-str)));
    21722229  /* not reached */
    21732230  return mrb_fixnum_value(0);
     2231}
     2232
     2233MRB_API mrb_value
     2234mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
     2235{
     2236  return mrb_str_len_to_inum(mrb, str, strlen(str), base, badcheck);
    21742237}
    21752238
    … …  
    21832246
    21842247  if (!p || p[len] != '\0') {
     2248    if (MRB_FROZEN_P(ps)) {
     2249      *ptr = str = mrb_str_dup(mrb, str);
     2250      ps = mrb_str_ptr(str);
     2251    }
    21852252    mrb_str_modify(mrb, ps);
    21862253    return RSTR_PTR(ps);
    … …  
    21952262  mrb_int len;
    21962263
    2197   if (badcheck) {
    2198     /* Raises if the string contains a null character (the badcheck) */
    2199     s = mrb_string_value_cstr(mrb, &str);
    2200   }
    2201   else {
    2202     s = mrb_string_value_ptr(mrb, str);
    2203   }
    2204   if (s) {
    2205     len = RSTRING_LEN(str);
    2206     if (s[len]) {    /* no sentinel somehow */
    2207       struct RString *temp_str = str_new(mrb, s, len);
    2208       s = RSTR_PTR(temp_str);
    2209     }
    2210   }
    2211   return mrb_cstr_to_inum(mrb, s, base, badcheck);
     2264  s = mrb_string_value_ptr(mrb, str);
     2265  len = RSTRING_LEN(str);
     2266  return mrb_str_len_to_inum(mrb, s, len, base, badcheck);
    22122267}
    22132268
    … …  
    22602315    return 0.0;
    22612316  }
    2262   d = strtod(p, &end);
     2317  d = mrb_float_read(p, &end);
    22632318  if (p == end) {
    22642319    if (badcheck) {
    … …  
    22982353    }
    22992354
    2300     d = strtod(p, &end);
     2355    d = mrb_float_read(p, &end);
    23012356    if (badcheck) {
    23022357      if (!end || p == end) goto bad;
    … …  
    26032658#endif
    26042659    c = *p;
    2605     if (c == '"'|| c == '\\' || (c == '#' && IS_EVSTR(p, pend))) {
     2660    if (c == '"'|| c == '\\' || (c == '#' && IS_EVSTR(p+1, pend))) {
    26062661      buf[0] = '\\'; buf[1] = c;
    26072662      mrb_str_cat(mrb, result, buf, 2);
    … …  
    26892744  mrb_define_method(mrb, s, "chomp",           mrb_str_chomp,           MRB_ARGS_ANY());  /* 15.2.10.5.9  */
    26902745  mrb_define_method(mrb, s, "chomp!",          mrb_str_chomp_bang,      MRB_ARGS_ANY());  /* 15.2.10.5.10 */
    2691   mrb_define_method(mrb, s, "chop",            mrb_str_chop,            MRB_ARGS_REQ(1)); /* 15.2.10.5.11 */
    2692   mrb_define_method(mrb, s, "chop!",           mrb_str_chop_bang,       MRB_ARGS_REQ(1)); /* 15.2.10.5.12 */
     2746  mrb_define_method(mrb, s, "chop",            mrb_str_chop,            MRB_ARGS_NONE()); /* 15.2.10.5.11 */
     2747  mrb_define_method(mrb, s, "chop!",           mrb_str_chop_bang,       MRB_ARGS_NONE()); /* 15.2.10.5.12 */
    26932748  mrb_define_method(mrb, s, "downcase",        mrb_str_downcase,        MRB_ARGS_NONE()); /* 15.2.10.5.13 */
    26942749  mrb_define_method(mrb, s, "downcase!",       mrb_str_downcase_bang,   MRB_ARGS_NONE()); /* 15.2.10.5.14 */
    … …  
    27202775  mrb_define_method(mrb, s, "inspect",         mrb_str_inspect,         MRB_ARGS_NONE()); /* 15.2.10.5.46(x) */
    27212776  mrb_define_method(mrb, s, "bytes",           mrb_str_bytes,           MRB_ARGS_NONE());
    2722 
    2723   mrb_define_method(mrb, s, "freeze",          mrb_str_freeze,          MRB_ARGS_NONE());
    2724 }
     2777}
     2778
     2779/*
     2780 *      Source code for the "strtod" library procedure.
     2781 *
     2782 * Copyright (c) 1988-1993 The Regents of the University of California.
     2783 * Copyright (c) 1994 Sun Microsystems, Inc.
     2784 *
     2785 * Permission to use, copy, modify, and distribute this
     2786 * software and its documentation for any purpose and without
     2787 * fee is hereby granted, provided that the above copyright
     2788 * notice appear in all copies.  The University of California
     2789 * makes no representations about the suitability of this
     2790 * software for any purpose.  It is provided "as is" without
     2791 * express or implied warranty.
     2792 *
     2793 * RCS: @(#) $Id$
     2794 */
     2795
     2796#include <ctype.h>
     2797#include <errno.h>
     2798
     2799static const int maxExponent = 511; /* Largest possible base 10 exponent.  Any
     2800                                     * exponent larger than this will already
     2801                                     * produce underflow or overflow, so there's
     2802                                     * no need to worry about additional digits.
     2803                                     */
     2804static const double powersOf10[] = {/* Table giving binary powers of 10.  Entry */
     2805    10.,                            /* is 10^2^i.  Used to convert decimal */
     2806    100.,                           /* exponents into floating-point numbers. */
     2807    1.0e4,
     2808    1.0e8,
     2809    1.0e16,
     2810    1.0e32,
     2811    1.0e64,
     2812    1.0e128,
     2813    1.0e256
     2814};
     2815
     2816MRB_API double
     2817mrb_float_read(const char *string, char **endPtr)
     2818/*  const char *string;            A decimal ASCII floating-point number,
     2819                                 * optionally preceded by white space.
     2820                                 * Must have form "-I.FE-X", where I is the
     2821                                 * integer part of the mantissa, F is the
     2822                                 * fractional part of the mantissa, and X
     2823                                 * is the exponent.  Either of the signs
     2824                                 * may be "+", "-", or omitted.  Either I
     2825                                 * or F may be omitted, or both.  The decimal
     2826                                 * point isn't necessary unless F is present.
     2827                                 * The "E" may actually be an "e".  E and X
     2828                                 * may both be omitted (but not just one).
     2829                                 */
     2830/*  char **endPtr;                 If non-NULL, store terminating character's
     2831                                 * address here. */
     2832{
     2833    int sign, expSign = FALSE;
     2834    double fraction, dblExp;
     2835    const double *d;
     2836    register const char *p;
     2837    register int c;
     2838    int exp = 0;                /* Exponent read from "EX" field. */
     2839    int fracExp = 0;            /* Exponent that derives from the fractional
     2840                                 * part.  Under normal circumstatnces, it is
     2841                                 * the negative of the number of digits in F.
     2842                                 * However, if I is very long, the last digits
     2843                                 * of I get dropped (otherwise a long I with a
     2844                                 * large negative exponent could cause an
     2845                                 * unnecessary overflow on I alone).  In this
     2846                                 * case, fracExp is incremented one for each
     2847                                 * dropped digit. */
     2848    int mantSize;               /* Number of digits in mantissa. */
     2849    int decPt;                  /* Number of mantissa digits BEFORE decimal
     2850                                 * point. */
     2851    const char *pExp;           /* Temporarily holds location of exponent
     2852                                 * in string. */
     2853
     2854    /*
     2855     * Strip off leading blanks and check for a sign.
     2856     */
     2857
     2858    p = string;
     2859    while (isspace(*p)) {
     2860        p += 1;
     2861    }
     2862    if (*p == '-') {
     2863        sign = TRUE;
     2864        p += 1;
     2865    }
     2866    else {
     2867        if (*p == '+') {
     2868            p += 1;
     2869        }
     2870        sign = FALSE;
     2871    }
     2872
     2873    /*
     2874     * Count the number of digits in the mantissa (including the decimal
     2875     * point), and also locate the decimal point.
     2876     */
     2877
     2878    decPt = -1;
     2879    for (mantSize = 0; ; mantSize += 1)
     2880    {
     2881        c = *p;
     2882        if (!isdigit(c)) {
     2883            if ((c != '.') || (decPt >= 0)) {
     2884                break;
     2885            }
     2886            decPt = mantSize;
     2887        }
     2888        p += 1;
     2889    }
     2890
     2891    /*
     2892     * Now suck up the digits in the mantissa.  Use two integers to
     2893     * collect 9 digits each (this is faster than using floating-point).
     2894     * If the mantissa has more than 18 digits, ignore the extras, since
     2895     * they can't affect the value anyway.
     2896     */
     2897
     2898    pExp  = p;
     2899    p -= mantSize;
     2900    if (decPt < 0) {
     2901        decPt = mantSize;
     2902    }
     2903    else {
     2904        mantSize -= 1;                  /* One of the digits was the point. */
     2905    }
     2906    if (mantSize > 18) {
     2907        if (decPt - 18 > 29999) {
     2908            fracExp = 29999;
     2909        }
     2910        else {
     2911            fracExp = decPt - 18;
     2912        }
     2913        mantSize = 18;
     2914    }
     2915    else {
     2916        fracExp = decPt - mantSize;
     2917    }
     2918    if (mantSize == 0) {
     2919        fraction = 0.0;
     2920        p = string;
     2921        goto done;
     2922    }
     2923    else {
     2924        int frac1, frac2;
     2925        frac1 = 0;
     2926        for ( ; mantSize > 9; mantSize -= 1)
     2927        {
     2928            c = *p;
     2929            p += 1;
     2930            if (c == '.') {
     2931                c = *p;
     2932                p += 1;
     2933            }
     2934            frac1 = 10*frac1 + (c - '0');
     2935        }
     2936        frac2 = 0;
     2937        for (; mantSize > 0; mantSize -= 1)
     2938        {
     2939            c = *p;
     2940            p += 1;
     2941            if (c == '.') {
     2942                c = *p;
     2943                p += 1;
     2944            }
     2945            frac2 = 10*frac2 + (c - '0');
     2946        }
     2947        fraction = (1.0e9 * frac1) + frac2;
     2948    }
     2949
     2950    /*
     2951     * Skim off the exponent.
     2952     */
     2953
     2954    p = pExp;
     2955    if ((*p == 'E') || (*p == 'e')) {
     2956        p += 1;
     2957        if (*p == '-') {
     2958            expSign = TRUE;
     2959            p += 1;
     2960        }
     2961        else {
     2962            if (*p == '+') {
     2963                p += 1;
     2964            }
     2965            expSign = FALSE;
     2966        }
     2967        while (isdigit(*p)) {
     2968            exp = exp * 10 + (*p - '0');
     2969            if (exp > 19999) {
     2970                exp = 19999;
     2971            }
     2972            p += 1;
     2973        }
     2974    }
     2975    if (expSign) {
     2976        exp = fracExp - exp;
     2977    }
     2978    else {
     2979        exp = fracExp + exp;
     2980    }
     2981
     2982    /*
     2983     * Generate a floating-point number that represents the exponent.
     2984     * Do this by processing the exponent one bit at a time to combine
     2985     * many powers of 2 of 10. Then combine the exponent with the
     2986     * fraction.
     2987     */
     2988
     2989    if (exp < 0) {
     2990        expSign = TRUE;
     2991        exp = -exp;
     2992    }
     2993    else {
     2994        expSign = FALSE;
     2995    }
     2996    if (exp > maxExponent) {
     2997        exp = maxExponent;
     2998        errno = ERANGE;
     2999    }
     3000    dblExp = 1.0;
     3001    for (d = powersOf10; exp != 0; exp >>= 1, d += 1) {
     3002        if (exp & 01) {
     3003            dblExp *= *d;
     3004        }
     3005    }
     3006    if (expSign) {
     3007        fraction /= dblExp;
     3008    }
     3009    else {
     3010        fraction *= dblExp;
     3011    }
     3012
     3013done:
     3014    if (endPtr != NULL) {
     3015        *endPtr = (char *) p;
     3016    }
     3017
     3018    if (sign) {
     3019        return -fraction;
     3020    }
     3021    return fraction;
     3022}

  • EcnlProtoTool/trunk/mruby-1.3.0/src/symbol.c

    r321 r331  
    77#include <limits.h>
    88#include <string.h>
    9 #include "mruby.h"
    10 #include "mruby/khash.h"
    11 #include "mruby/string.h"
    12 #include "mruby/dump.h"
     9#include <mruby.h>
     10#include <mruby/khash.h>
     11#include <mruby/string.h>
     12#include <mruby/dump.h>
     13#include <mruby/class.h>
    1314
    1415/* ------------------------------------------------------ */
    … …  
    355356      break;
    356357    case '!':
    357       if (*++m == '=') ++m;
     358      switch (*++m) {
     359        case '=': case '~': ++m;
     360      }
    358361      break;
    359362    case '+': case '-':
    … …  
    480483
    481484  mrb->symbol_class = sym = mrb_define_class(mrb, "Symbol", mrb->object_class);                 /* 15.2.11 */
     485  MRB_SET_INSTANCE_TT(sym, MRB_TT_SYMBOL);
     486  mrb_undef_class_method(mrb,  sym, "new");
    482487
    483488  mrb_define_method(mrb, sym, "===",             sym_equal,      MRB_ARGS_REQ(1));              /* 15.2.11.3.1  */

  • EcnlProtoTool/trunk/mruby-1.3.0/src/value_array.h

    r321 r331  
    22#define MRB_VALUE_ARRAY_H__
    33
    4 #include "mruby.h"
     4#include <mruby.h>
    55
    66static inline void

  • EcnlProtoTool/trunk/mruby-1.3.0/src/variable.c

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
    8 #include "mruby/array.h"
    9 #include "mruby/class.h"
    10 #include "mruby/proc.h"
    11 #include "mruby/string.h"
     7#include <mruby.h>
     8#include <mruby/array.h>
     9#include <mruby/class.h>
     10#include <mruby/proc.h>
     11#include <mruby/string.h>
    1212
    1313typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
    … …  
    4545  iv_tbl *t;
    4646
    47   t = mrb_malloc(mrb, sizeof(iv_tbl));
     47  t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
    4848  t->size = 0;
    4949  t->rootseg =  NULL;
    … …  
    103103  }
    104104
    105   seg = mrb_malloc(mrb, sizeof(segment));
     105  seg = (segment*)mrb_malloc(mrb, sizeof(segment));
    106106  if (!seg) return;
    107107  seg->next = NULL;
    … …  
    283283#else
    284284
    285 #include "mruby/khash.h"
     285#include <mruby/khash.h>
    286286
    287287#ifndef MRB_IVHASH_INIT_SIZE
    … …  
    490490  iv_tbl *t = obj->iv;
    491491
     492  if (MRB_FROZEN_P(obj)) {
     493    mrb_raisef(mrb, E_RUNTIME_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
     494  }
    492495  if (!t) {
    493496    t = obj->iv = iv_new(mrb);
    … …  
    757760
    758761MRB_API mrb_value
    759 mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym)
     762mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
    760763{
    761764  struct RClass * cls = c;
    762765  mrb_value v;
     766  int given = FALSE;
    763767
    764768  while (c) {
    765769    if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
    766       return v;
     770      given = TRUE;
    767771    }
    768772    c = c->super;
    769773  }
     774  if (given) return v;
    770775  if (cls && cls->tt == MRB_TT_SCLASS) {
    771776    mrb_value klass;
    … …  
    774779                           mrb_intern_lit(mrb, "__attached__"));
    775780    c = mrb_class_ptr(klass);
    776     if (c->tt == MRB_TT_CLASS) {
     781    if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
     782      given = FALSE;
    777783      while (c) {
    778784        if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
    779           return v;
     785          given = TRUE;
    780786        }
    781787        c = c->super;
    782788      }
     789      if (given) return v;
    783790    }
    784791  }
    … …  
    813820  }
    814821
    815   if (!cls->iv) {
    816     cls->iv = iv_new(mrb);
    817   }
    818 
    819   mrb_write_barrier(mrb, (struct RBasic*)cls);
    820   iv_put(mrb, cls->iv, sym, v);
     822  if (cls && cls->tt == MRB_TT_SCLASS) {
     823    mrb_value klass;
     824
     825    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls,
     826                           mrb_intern_lit(mrb, "__attached__"));
     827    switch (mrb_type(klass)) {
     828    case MRB_TT_CLASS:
     829    case MRB_TT_MODULE:
     830    case MRB_TT_SCLASS:
     831      c = mrb_class_ptr(klass);
     832      break;
     833    default:
     834      c = cls;
     835      break;
     836    }
     837  }
     838  else{
     839    c = cls;
     840  }
     841
     842  if (!c->iv) {
     843    c->iv = iv_new(mrb);
     844  }
     845
     846  mrb_write_barrier(mrb, (struct RBasic*)c);
     847  iv_put(mrb, c->iv, sym, v);
    821848}
    822849
    … …  
    927954      return v;
    928955    }
    929     if (c->tt == MRB_TT_SCLASS) {
     956    c2 = c;
     957    while (c2 && c2->tt == MRB_TT_SCLASS) {
    930958      mrb_value klass;
    931       klass = mrb_obj_iv_get(mrb, (struct RObject *)c,
     959      klass = mrb_obj_iv_get(mrb, (struct RObject *)c2,
    932960                             mrb_intern_lit(mrb, "__attached__"));
    933961      c2 = mrb_class_ptr(klass);
    934       if (c2->tt == MRB_TT_CLASS)
    935         c = c2;
    936     }
     962    }
     963    if (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE) c = c2;
    937964    c2 = c;
    938965    for (;;) {

  • EcnlProtoTool/trunk/mruby-1.3.0/src/version.c

    r321 r331  
    1 #include "mruby.h"
    2 #include "mruby/variable.h"
     1#include <mruby.h>
     2#include <mruby/variable.h>
    33
    44void
    … …  
    1010  mrb_define_global_const(mrb, "RUBY_ENGINE", mrb_str_new_lit(mrb, MRUBY_RUBY_ENGINE));
    1111  mrb_define_global_const(mrb, "RUBY_ENGINE_VERSION", mruby_version);
    12   mrb_define_global_const(mrb, "MRUBY_VERSION", mrb_str_new_lit(mrb, MRUBY_VERSION));
     12  mrb_define_global_const(mrb, "MRUBY_VERSION", mruby_version);
    1313  mrb_define_global_const(mrb, "MRUBY_RELEASE_NO", mrb_fixnum_value(MRUBY_RELEASE_NO));
    1414  mrb_define_global_const(mrb, "MRUBY_RELEASE_DATE", mrb_str_new_lit(mrb, MRUBY_RELEASE_DATE));

  • EcnlProtoTool/trunk/mruby-1.3.0/src/vm.c

    r321 r331  
    88#include <stdarg.h>
    99#include <math.h>
    10 #include "mruby.h"
    11 #include "mruby/array.h"
    12 #include "mruby/class.h"
    13 #include "mruby/hash.h"
    14 #include "mruby/irep.h"
    15 #include "mruby/numeric.h"
    16 #include "mruby/proc.h"
    17 #include "mruby/range.h"
    18 #include "mruby/string.h"
    19 #include "mruby/variable.h"
    20 #include "mruby/error.h"
    21 #include "mruby/opcode.h"
     10#include <mruby.h>
     11#include <mruby/array.h>
     12#include <mruby/class.h>
     13#include <mruby/hash.h>
     14#include <mruby/irep.h>
     15#include <mruby/numeric.h>
     16#include <mruby/proc.h>
     17#include <mruby/range.h>
     18#include <mruby/string.h>
     19#include <mruby/variable.h>
     20#include <mruby/error.h>
     21#include <mruby/opcode.h>
    2222#include "value_array.h"
    23 #include "mruby/throw.h"
    24 
    25 #ifdef MRB_DISABLE_STDIO
     23#include <mruby/throw.h>
     24
     25#ifndef MRB_DISABLE_STDIO
    2626#if defined(__cplusplus)
    2727extern "C" {
    … …  
    3636#define CALLINFO_INIT_SIZE 32
    3737
     38#ifndef ENSURE_STACK_INIT_SIZE
     39#define ENSURE_STACK_INIT_SIZE 16
     40#endif
     41
     42#ifndef RESCUE_STACK_INIT_SIZE
     43#define RESCUE_STACK_INIT_SIZE 16
     44#endif
     45
    3846/* Define amount of linear stack growth. */
    3947#ifndef MRB_STACK_GROWTH
    4048#define MRB_STACK_GROWTH 128
     49#endif
     50
     51/* Maximum mrb_funcall() depth. Should be set lower on memory constrained systems. */
     52#ifndef MRB_FUNCALL_DEPTH_MAX
     53#define MRB_FUNCALL_DEPTH_MAX 512
    4154#endif
    4255
    … …  
    5467
    5568#define ARENA_RESTORE(mrb,ai) (mrb)->gc.arena_idx = (ai)
     69
     70#define CALL_MAXARGS 127
     71
     72void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args);
    5673
    5774static inline void
    … …  
    99116
    100117static inline void
    101 envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase)
     118envadjust(mrb_state *mrb, mrb_value *oldbase, mrb_value *newbase, size_t size)
    102119{
    103120  mrb_callinfo *ci = mrb->c->cibase;
    … …  
    106123  while (ci <= mrb->c->ci) {
    107124    struct REnv *e = ci->env;
    108     if (e && MRB_ENV_STACK_SHARED_P(e)) {
     125    mrb_value *st;
     126
     127    if (e && MRB_ENV_STACK_SHARED_P(e) &&
     128        (st = e->stack) && oldbase <= st && st < oldbase+size) {
    109129      ptrdiff_t off = e->stack - oldbase;
    110130
    … …  
    116136}
    117137
    118 static inline void
    119 init_new_stack_space(mrb_state *mrb, int room, int keep)
    120 {
    121   if (room > keep) {
    122     /* do not leave uninitialized malloc region */
    123     stack_clear(&(mrb->c->stack[keep]), room - keep);
    124   }
    125 }
    126 
    127138/** def rec ; $deep =+ 1 ; if $deep > 1000 ; return 0 ; end ; rec ; end  */
    128139
    129140static void
    130 stack_extend_alloc(mrb_state *mrb, int room, int keep)
     141stack_extend_alloc(mrb_state *mrb, int room)
    131142{
    132143  mrb_value *oldbase = mrb->c->stbase;
    133   int size = mrb->c->stend - mrb->c->stbase;
    134   int off = mrb->c->stack - mrb->c->stbase;
    135 
     144  mrb_value *newstack;
     145  size_t oldsize = mrb->c->stend - mrb->c->stbase;
     146  size_t size = oldsize;
     147  size_t off = mrb->c->stack - mrb->c->stbase;
     148
     149  if (off > size) size = off;
    136150#ifdef MRB_STACK_EXTEND_DOUBLING
    137151  if (room <= size)
    … …  
    149163#endif
    150164
    151   mrb->c->stbase = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
     165  newstack = (mrb_value *)mrb_realloc(mrb, mrb->c->stbase, sizeof(mrb_value) * size);
     166  if (newstack == NULL) {
     167    mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
     168  }
     169  stack_clear(&(newstack[oldsize]), size - oldsize);
     170  envadjust(mrb, oldbase, newstack, size);
     171  mrb->c->stbase = newstack;
    152172  mrb->c->stack = mrb->c->stbase + off;
    153173  mrb->c->stend = mrb->c->stbase + size;
    154   envadjust(mrb, oldbase, mrb->c->stbase);
    155174
    156175  /* Raise an exception if the new stack size will be too large,
    157176     to prevent infinite recursion. However, do this only after resizing the stack, so mrb_raise has stack space to work with. */
    158177  if (size > MRB_STACK_MAX) {
    159     init_new_stack_space(mrb, room, keep);
    160     mrb_raise(mrb, E_SYSSTACK_ERROR, "stack level too deep. (limit=" MRB_STRINGIZE(MRB_STACK_MAX) ")");
     178    mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
    161179  }
    162180}
    163181
    164182static inline void
    165 stack_extend(mrb_state *mrb, int room, int keep)
     183stack_extend(mrb_state *mrb, int room)
    166184{
    167185  if (mrb->c->stack + room >= mrb->c->stend) {
    168     stack_extend_alloc(mrb, room, keep);
    169   }
    170   init_new_stack_space(mrb, room, keep);
     186    stack_extend_alloc(mrb, room);
     187  }
    171188}
    172189
    … …  
    188205  int cioff = e->cioff;
    189206
    190   if (MRB_ENV_STACK_SHARED_P(e) && mrb->c->cibase[cioff].proc &&
    191       MRB_PROC_STRICT_P(mrb->c->cibase[cioff].proc)) {
     207  if (MRB_ENV_STACK_SHARED_P(e) && e->cxt.c->cibase[cioff].proc &&
     208      MRB_PROC_STRICT_P(e->cxt.c->cibase[cioff].proc)) {
    192209    return TRUE;
    193210  }
    … …  
    210227#define CI_ACC_SKIP    -1
    211228#define CI_ACC_DIRECT  -2
     229#define CI_ACC_RESUMED -3
    212230
    213231static mrb_callinfo*
    … …  
    217235  mrb_callinfo *ci = c->ci;
    218236
    219   int eidx = ci->eidx;
    220237  int ridx = ci->ridx;
    221238
    … …  
    228245  }
    229246  ci = ++c->ci;
    230   ci->eidx = eidx;
     247  ci->epos = mrb->c->eidx;
    231248  ci->ridx = ridx;
    232249  ci->env = 0;
    … …  
    234251  ci->err = 0;
    235252  ci->proc = 0;
     253  ci->acc = 0;
    236254
    237255  return ci;
     256}
     257
     258MRB_API void
     259mrb_env_unshare(mrb_state *mrb, struct REnv *e)
     260{
     261  size_t len = (size_t)MRB_ENV_STACK_LEN(e);
     262  ptrdiff_t cioff = e->cioff;
     263  mrb_value *p;
     264
     265  if (!MRB_ENV_STACK_SHARED_P(e)) return;
     266  if (e->cxt.c != mrb->c) return;
     267  if (e->cioff == 0 && e->cxt.c == mrb->root_c) return;
     268  MRB_ENV_UNSHARE_STACK(e);
     269  if (!e->c) {
     270    /* save block argument position (negated) */
     271    e->cioff = -e->cxt.c->cibase[cioff].argc-1;
     272  }
     273  e->cxt.mid = e->cxt.c->cibase[cioff].mid;
     274  p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len);
     275  if (len > 0) {
     276    stack_copy(p, e->stack, len);
     277  }
     278  e->stack = p;
     279  mrb_write_barrier(mrb, (struct RBasic *)e);
    238280}
    239281
    … …  
    242284{
    243285  struct mrb_context *c = mrb->c;
    244 
    245   if (c->ci->env) {
    246     struct REnv *e = c->ci->env;
    247     size_t len = (size_t)MRB_ENV_STACK_LEN(e);
    248     mrb_value *p = (mrb_value *)mrb_malloc(mrb, sizeof(mrb_value)*len);
    249 
    250     MRB_ENV_UNSHARE_STACK(e);
    251     if (len > 0) {
    252       stack_copy(p, e->stack, len);
    253     }
    254     e->stack = p;
    255     mrb_write_barrier(mrb, (struct RBasic *)e);
    256   }
     286  struct REnv *env = c->ci->env;
    257287
    258288  c->ci--;
    259 }
     289
     290  if (env) {
     291    mrb_env_unshare(mrb, env);
     292  }
     293}
     294
     295void mrb_exc_set(mrb_state *mrb, mrb_value exc);
    260296
    261297static void
    … …  
    263299{
    264300  struct RProc *p;
    265   mrb_callinfo *ci;
     301  mrb_callinfo *ci = mrb->c->ci;
    266302  mrb_value *self = mrb->c->stack;
    267303  struct RObject *exc;
     304  ptrdiff_t cioff;
     305  int ai = mrb_gc_arena_save(mrb);
    268306
    269307  if (i<0) return;
     308  if (ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) {
     309    mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
     310  }
    270311  p = mrb->c->ensure[i];
    271312  if (!p) return;
    272   if (mrb->c->ci->eidx > i)
    273     mrb->c->ci->eidx = i;
     313  mrb->c->ensure[i] = NULL;
     314  cioff = ci - mrb->c->cibase;
    274315  ci = cipush(mrb);
    275316  ci->stackent = mrb->c->stack;
    … …  
    282323  mrb->c->stack = mrb->c->stack + ci[-1].nregs;
    283324  exc = mrb->exc; mrb->exc = 0;
     325  if (exc) {
     326    mrb_gc_protect(mrb, mrb_obj_value(exc));
     327  }
    284328  mrb_run(mrb, p, *self);
    285   mrb->c->ensure[i] = NULL;
     329  mrb->c->ci = mrb->c->cibase + cioff;
    286330  if (!mrb->exc) mrb->exc = exc;
     331  mrb_gc_arena_restore(mrb, ai);
    287332}
    288333
    … …  
    335380    }
    336381    MRB_END_EXC(&c_jmp);
     382    mrb->jmp = 0;
    337383  }
    338384  else {
    339385    struct RProc *p;
    340386    struct RClass *c;
    341     mrb_sym undef = 0;
    342387    mrb_callinfo *ci;
    343388    int n;
    … …  
    354399    p = mrb_method_search_vm(mrb, &c, mid);
    355400    if (!p) {
    356       undef = mid;
    357       mid = mrb_intern_lit(mrb, "method_missing");
    358       p = mrb_method_search_vm(mrb, &c, mid);
    359       n++; argc++;
     401      mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
     402      mrb_value args = mrb_ary_new_from_values(mrb, argc, argv);
     403      p = mrb_method_search_vm(mrb, &c, missing);
     404      if (!p) {
     405        mrb_method_missing(mrb, mid, self, args);
     406      }
     407      mrb_ary_unshift(mrb, args, mrb_symbol_value(mid));
     408      stack_extend(mrb, n+2);
     409      mrb->c->stack[n+1] = args;
     410      argc = -1;
     411    }
     412    if (mrb->c->ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) {
     413      mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
    360414    }
    361415    ci = cipush(mrb);
    … …  
    371425    if (MRB_PROC_CFUNC_P(p)) {
    372426      ci->nregs = argc + 2;
    373       stack_extend(mrb, ci->nregs, 0);
     427      stack_extend(mrb, ci->nregs);
     428    }
     429    else if (argc >= CALL_MAXARGS) {
     430      mrb_value args = mrb_ary_new_from_values(mrb, argc, argv);
     431      stack_extend(mrb, ci->nregs);
     432      mrb->c->stack[1] = args;
     433      ci->argc = -1;
     434      argc = 1;
    374435    }
    375436    else {
    376       ci->nregs = p->body.irep->nregs + n;
    377       stack_extend(mrb, ci->nregs, argc+2);
     437      if (argc < 0) argc = 1;
     438      ci->nregs = p->body.irep->nregs + argc;
     439      stack_extend(mrb, ci->nregs);
    378440    }
    379441    if (voff >= 0) {
    … …  
    381443    }
    382444    mrb->c->stack[0] = self;
    383     if (undef) {
    384       mrb->c->stack[1] = mrb_symbol_value(undef);
    385       if (argc > 1) {
    386         stack_copy(mrb->c->stack+2, argv, argc-1);
    387       }
    388     }
    389     else if (argc > 0) {
     445    if (ci->argc > 0) {
    390446      stack_copy(mrb->c->stack+1, argv, argc);
    391447    }
    … …  
    414470{
    415471  return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value());
     472}
     473
     474mrb_value
     475mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
     476{
     477  mrb_callinfo *ci = mrb->c->ci;
     478
     479  mrb->c->stack[0] = self;
     480  ci->proc = p;
     481  ci->target_class = p->target_class;
     482  if (MRB_PROC_CFUNC_P(p)) {
     483    return p->body.func(mrb, self);
     484  }
     485  if (ci->argc < 0) {
     486    stack_extend(mrb, (p->body.irep->nregs < 3) ? 3 : p->body.irep->nregs);
     487  }
     488  else {
     489    stack_extend(mrb, p->body.irep->nregs);
     490  }
     491
     492  ci->nregs = p->body.irep->nregs;
     493  ci = cipush(mrb);
     494  ci->nregs = 0;
     495  ci->target_class = 0;
     496  ci->pc = p->body.irep->iseq;
     497  ci->stackent = mrb->c->stack;
     498  ci->acc = 0;
     499
     500  return self;
    416501}
    417502
    … …  
    446531
    447532  mrb_get_args(mrb, "n*&", &name, &argv, &argc, &block);
     533  ci = mrb->c->ci;
     534  if (ci->acc < 0) {
     535  funcall:
     536    return mrb_funcall_with_block(mrb, self, name, argc, argv, block);
     537  }
    448538
    449539  c = mrb_class(mrb, self);
    … …  
    451541
    452542  if (!p) {                     /* call method_mising */
    453     return mrb_funcall_with_block(mrb, self, name, argc, argv, block);
    454   }
    455 
    456   ci = mrb->c->ci;
     543    goto funcall;
     544  }
     545
    457546  ci->mid = name;
    458547  ci->target_class = c;
    459   ci->proc = p;
    460548  regs = mrb->c->stack+1;
    461549  /* remove first symbol from arguments */
    … …  
    470558  }
    471559
    472   if (MRB_PROC_CFUNC_P(p)) {
    473     return p->body.func(mrb, self);
    474   }
    475 
    476   if (ci->argc < 0) {
    477     stack_extend(mrb, (p->body.irep->nregs < 3) ? 3 : p->body.irep->nregs, 3);
    478   }
    479   else {
    480     stack_extend(mrb, p->body.irep->nregs, ci->argc+2);
    481   }
    482 
    483   ci->nregs = p->body.irep->nregs;
    484   ci = cipush(mrb);
    485   ci->nregs = 0;
    486   ci->target_class = 0;
    487   ci->pc = p->body.irep->iseq;
    488   ci->stackent = mrb->c->stack;
    489   ci->acc = 0;
    490 
    491   return self;
     560  return mrb_exec_irep(mrb, self, p);
    492561}
    493562
    … …  
    497566  struct RProc *p;
    498567  mrb_callinfo *ci;
     568  mrb_int max = 3;
    499569
    500570  if (mrb_nil_p(blk)) {
    … …  
    503573  ci = mrb->c->ci;
    504574  if (ci->acc == CI_ACC_DIRECT) {
    505     return mrb_yield_with_class(mrb, blk, 0, 0, self, c);
     575    ci->target_class = c;
     576    return mrb_yield_cont(mrb, blk, self, 1, &self);
    506577  }
    507578  ci->target_class = c;
    508579  p = mrb_proc_ptr(blk);
    509580  ci->proc = p;
     581  ci->argc = 1;
     582  ci->mid = ci[-1].mid;
    510583  if (MRB_PROC_CFUNC_P(p)) {
     584    stack_extend(mrb, 3);
     585    mrb->c->stack[0] = self;
     586    mrb->c->stack[1] = self;
     587    mrb->c->stack[2] = mrb_nil_value();
    511588    return p->body.func(mrb, self);
    512589  }
    513590  ci->nregs = p->body.irep->nregs;
     591  if (max < ci->nregs) max = ci->nregs;
     592  stack_extend(mrb, max);
     593  mrb->c->stack[0] = self;
     594  mrb->c->stack[1] = self;
     595  mrb->c->stack[2] = mrb_nil_value();
    514596  ci = cipush(mrb);
    515597  ci->nregs = 0;
    … …  
    600682    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
    601683  }
     684  if (mrb->c->ci - mrb->c->cibase > MRB_FUNCALL_DEPTH_MAX) {
     685    mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
     686  }
    602687  p = mrb_proc_ptr(b);
    603688  ci = cipush(mrb);
    … …  
    611696  if (MRB_PROC_CFUNC_P(p)) {
    612697    ci->nregs = argc + 2;
    613     stack_extend(mrb, ci->nregs, 0);
     698    stack_extend(mrb, ci->nregs);
    614699  }
    615700  else {
    616701    ci->nregs = p->body.irep->nregs;
    617     stack_extend(mrb, ci->nregs, argc+2);
     702    stack_extend(mrb, ci->nregs);
    618703  }
    619704
    … …  
    627712    val = p->body.func(mrb, self);
    628713    mrb->c->stack = mrb->c->ci->stackent;
    629     cipop(mrb);
    630714  }
    631715  else {
     716    int cioff = mrb->c->ci - mrb->c->cibase;
    632717    val = mrb_run(mrb, p, self);
    633   }
     718    mrb->c->ci = mrb->c->cibase + cioff;
     719  }
     720  cipop(mrb);
    634721  return val;
    635722}
    … …  
    649736
    650737  return mrb_yield_with_class(mrb, b, 1, &arg, p->env->stack[0], p->target_class);
     738}
     739
     740mrb_value
     741mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const mrb_value *argv)
     742{
     743  struct RProc *p;
     744  mrb_callinfo *ci;
     745
     746  if (mrb_nil_p(b)) {
     747    mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
     748  }
     749  if (mrb_type(b) != MRB_TT_PROC) {
     750    mrb_raise(mrb, E_TYPE_ERROR, "not a block");
     751  }
     752
     753  p = mrb_proc_ptr(b);
     754  ci = mrb->c->ci;
     755
     756  stack_extend(mrb, 3);
     757  mrb->c->stack[1] = mrb_ary_new_from_values(mrb, argc, argv);
     758  mrb->c->stack[2] = mrb_nil_value();
     759  ci->argc = -1;
     760  return mrb_exec_irep(mrb, self, p);
     761}
     762
     763static struct RBreak*
     764break_new(mrb_state *mrb, struct RProc *p, mrb_value val)
     765{
     766  struct RBreak *brk;
     767
     768  brk = (struct RBreak*)mrb_obj_alloc(mrb, MRB_TT_BREAK, NULL);
     769  brk->iv = NULL;
     770  brk->proc = p;
     771  brk->val = val;
     772
     773  return brk;
    651774}
    652775
    … …  
    670793  mrb_str_cat(mrb, msg, kind_str[kind], kind_str_len[kind]);
    671794  exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg);
    672   mrb->exc = mrb_obj_ptr(exc);
     795  mrb_exc_set(mrb, exc);
    673796}
    674797
    … …  
    678801  mrb_value exc;
    679802  mrb_value str;
    680 
     803  mrb_int argc = mrb->c->ci->argc;
     804
     805  if (argc < 0) {
     806    mrb_value args = mrb->c->stack[1];
     807    if (mrb_array_p(args)) {
     808      argc = RARRAY_LEN(args);
     809    }
     810  }
    681811  if (mrb->c->ci->mid) {
    682812    str = mrb_format(mrb, "'%S': wrong number of arguments (%S for %S)",
    683813                  mrb_sym2str(mrb, mrb->c->ci->mid),
    684                   mrb_fixnum_value(mrb->c->ci->argc), mrb_fixnum_value(num));
     814                  mrb_fixnum_value(argc), mrb_fixnum_value(num));
    685815  }
    686816  else {
    687817    str = mrb_format(mrb, "wrong number of arguments (%S for %S)",
    688                   mrb_fixnum_value(mrb->c->ci->argc), mrb_fixnum_value(num));
     818                     mrb_fixnum_value(argc), mrb_fixnum_value(num));
    689819  }
    690820  exc = mrb_exc_new_str(mrb, E_ARGUMENT_ERROR, str);
    691   mrb->exc = mrb_obj_ptr(exc);
     821  mrb_exc_set(mrb, exc);
    692822}
    693823
    … …  
    700830#endif
    701831
     832#ifdef MRB_BYTECODE_DECODE_OPTION
     833#define BYTECODE_DECODER(x) ((mrb)->bytecode_decoder)?(mrb)->bytecode_decoder((mrb), (x)):(x)
     834#else
     835#define BYTECODE_DECODER(x) (x)
     836#endif
     837
     838
    702839#if defined __GNUC__ || defined __clang__ || defined __INTEL_COMPILER
    703840#define DIRECT_THREADED
    … …  
    706843#ifndef DIRECT_THREADED
    707844
    708 #define INIT_DISPATCH for (;;) { i = *pc; CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (GET_OPCODE(i)) {
     845#define INIT_DISPATCH for (;;) { i = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (GET_OPCODE(i)) {
    709846#define CASE(op) case op:
    710847#define NEXT pc++; break
    … …  
    716853#define INIT_DISPATCH JUMP; return mrb_nil_value();
    717854#define CASE(op) L_ ## op:
    718 #define NEXT i=*++pc; CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[GET_OPCODE(i)]
    719 #define JUMP i=*pc; CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[GET_OPCODE(i)]
     855#define NEXT i=BYTECODE_DECODER(*++pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[GET_OPCODE(i)]
     856#define JUMP i=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[GET_OPCODE(i)]
    720857
    721858#define END_DISPATCH
    … …  
    723860#endif
    724861
    725 #define CALL_MAXARGS 127
    726 
    727 void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args);
    728 
    729862MRB_API mrb_value
    730 mrb_context_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
     863mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
     864{
     865  mrb_irep *irep = proc->body.irep;
     866  mrb_value result;
     867  struct mrb_context *c = mrb->c;
     868  int cioff = c->ci - c->cibase;
     869  unsigned int nregs = irep->nregs;
     870
     871  if (!c->stack) {
     872    stack_init(mrb);
     873  }
     874  if (stack_keep > nregs)
     875    nregs = stack_keep;
     876  stack_extend(mrb, nregs);
     877  stack_clear(c->stack + stack_keep, nregs - stack_keep);
     878  c->stack[0] = self;
     879  result = mrb_vm_exec(mrb, proc, irep->iseq);
     880  if (c->ci - c->cibase > cioff) {
     881    c->ci = c->cibase + cioff;
     882  }
     883  if (mrb->c != c) {
     884    if (mrb->c->fib) {
     885      mrb_write_barrier(mrb, (struct RBasic*)mrb->c->fib);
     886    }
     887    mrb->c = c;
     888  }
     889  return result;
     890}
     891
     892MRB_API mrb_value
     893mrb_vm_exec(mrb_state *mrb, struct RProc *proc, mrb_code *pc)
    731894{
    732895  /* mrb_assert(mrb_proc_cfunc_p(proc)) */
    733896  mrb_irep *irep = proc->body.irep;
    734   mrb_code *pc = irep->iseq;
    735897  mrb_value *pool = irep->pool;
    736898  mrb_sym *syms = irep->syms;
    737   mrb_value *regs = NULL;
    738899  mrb_code i;
    739900  int ai = mrb_gc_arena_save(mrb);
    … …  
    773934  if (exc_catched) {
    774935    exc_catched = FALSE;
     936    if (mrb->exc && mrb->exc->tt == MRB_TT_BREAK)
     937      goto L_BREAK;
    775938    goto L_RAISE;
    776939  }
    777940  mrb->jmp = &c_jmp;
    778   if (!mrb->c->stack) {
    779     stack_init(mrb);
    780   }
    781   stack_extend(mrb, irep->nregs, stack_keep);
    782941  mrb->c->ci->proc = proc;
    783942  mrb->c->ci->nregs = irep->nregs;
    784   regs = mrb->c->stack;
    785   regs[0] = self;
    786 
     943
     944#define regs (mrb->c->stack)
    787945  INIT_DISPATCH {
    788946    CASE(OP_NOP) {
    … …  
    793951    CASE(OP_MOVE) {
    794952      /* A B    R(A) := R(B) */
    795       regs[GETARG_A(i)] = regs[GETARG_B(i)];
     953      int a = GETARG_A(i);
     954      int b = GETARG_B(i);
     955      regs[a] = regs[b];
    796956      NEXT;
    797957    }
    … …  
    799959    CASE(OP_LOADL) {
    800960      /* A Bx   R(A) := Pool(Bx) */
    801       regs[GETARG_A(i)] = pool[GETARG_Bx(i)];
     961      int a = GETARG_A(i);
     962      int bx = GETARG_Bx(i);
     963#ifdef MRB_WORD_BOXING
     964      mrb_value val = pool[bx];
     965      if (mrb_float_p(val)) {
     966        val = mrb_float_value(mrb, mrb_float(val));
     967      }
     968      regs[a] = val;
     969#else
     970      regs[a] = pool[bx];
     971#endif
    802972      NEXT;
    803973    }
    … …  
    811981    CASE(OP_LOADSYM) {
    812982      /* A Bx   R(A) := Syms(Bx) */
    813       SET_SYM_VALUE(regs[GETARG_A(i)], syms[GETARG_Bx(i)]);
     983      int a = GETARG_A(i);
     984      int bx = GETARG_Bx(i);
     985      SET_SYM_VALUE(regs[a], syms[bx]);
    814986      NEXT;
    815987    }
    … …  
    817989    CASE(OP_LOADSELF) {
    818990      /* A      R(A) := self */
    819       regs[GETARG_A(i)] = regs[0];
     991      int a = GETARG_A(i);
     992      regs[a] = regs[0];
    820993      NEXT;
    821994    }
    … …  
    823996    CASE(OP_LOADT) {
    824997      /* A      R(A) := true */
    825       SET_TRUE_VALUE(regs[GETARG_A(i)]);
     998      int a = GETARG_A(i);
     999      SET_TRUE_VALUE(regs[a]);
    8261000      NEXT;
    8271001    }
    … …  
    8291003    CASE(OP_LOADF) {
    8301004      /* A      R(A) := false */
    831       SET_FALSE_VALUE(regs[GETARG_A(i)]);
     1005      int a = GETARG_A(i);
     1006      SET_FALSE_VALUE(regs[a]);
    8321007      NEXT;
    8331008    }
    … …  
    8351010    CASE(OP_GETGLOBAL) {
    8361011      /* A Bx   R(A) := getglobal(Syms(Bx)) */
    837       regs[GETARG_A(i)] = mrb_gv_get(mrb, syms[GETARG_Bx(i)]);
     1012      int a = GETARG_A(i);
     1013      int bx = GETARG_Bx(i);
     1014      mrb_value val = mrb_gv_get(mrb, syms[bx]);
     1015      regs[a] = val;
    8381016      NEXT;
    8391017    }
    8401018
    8411019    CASE(OP_SETGLOBAL) {
    842       /* setglobal(Syms(Bx), R(A)) */
    843       mrb_gv_set(mrb, syms[GETARG_Bx(i)], regs[GETARG_A(i)]);
     1020      /* A Bx   setglobal(Syms(Bx), R(A)) */
     1021      int a = GETARG_A(i);
     1022      int bx = GETARG_Bx(i);
     1023      mrb_gv_set(mrb, syms[bx], regs[a]);
    8441024      NEXT;
    8451025    }
    … …  
    8471027    CASE(OP_GETSPECIAL) {
    8481028      /* A Bx   R(A) := Special[Bx] */
    849       regs[GETARG_A(i)] = mrb_vm_special_get(mrb, GETARG_Bx(i));
     1029      int a = GETARG_A(i);
     1030      int bx = GETARG_Bx(i);
     1031      mrb_value val = mrb_vm_special_get(mrb, bx);
     1032      regs[a] = val;
    8501033      NEXT;
    8511034    }
    … …  
    8531036    CASE(OP_SETSPECIAL) {
    8541037      /* A Bx   Special[Bx] := R(A) */
    855       mrb_vm_special_set(mrb, GETARG_Bx(i), regs[GETARG_A(i)]);
     1038      int a = GETARG_A(i);
     1039      int bx = GETARG_Bx(i);
     1040      mrb_vm_special_set(mrb, bx, regs[a]);
    8561041      NEXT;
    8571042    }
    … …  
    8591044    CASE(OP_GETIV) {
    8601045      /* A Bx   R(A) := ivget(Bx) */
    861       regs[GETARG_A(i)] = mrb_vm_iv_get(mrb, syms[GETARG_Bx(i)]);
     1046      int a = GETARG_A(i);
     1047      int bx = GETARG_Bx(i);
     1048      mrb_value val = mrb_vm_iv_get(mrb, syms[bx]);
     1049      regs[a] = val;
    8621050      NEXT;
    8631051    }
    8641052
    8651053    CASE(OP_SETIV) {
    866       /* ivset(Syms(Bx),R(A)) */
    867       mrb_vm_iv_set(mrb, syms[GETARG_Bx(i)], regs[GETARG_A(i)]);
     1054      /* A Bx   ivset(Syms(Bx),R(A)) */
     1055      int a = GETARG_A(i);
     1056      int bx = GETARG_Bx(i);
     1057      mrb_vm_iv_set(mrb, syms[bx], regs[a]);
    8681058      NEXT;
    8691059    }
    … …  
    8711061    CASE(OP_GETCV) {
    8721062      /* A Bx   R(A) := cvget(Syms(Bx)) */
     1063      int a = GETARG_A(i);
     1064      int bx = GETARG_Bx(i);
     1065      mrb_value val;
    8731066      ERR_PC_SET(mrb, pc);
    874       regs[GETARG_A(i)] = mrb_vm_cv_get(mrb, syms[GETARG_Bx(i)]);
     1067      val = mrb_vm_cv_get(mrb, syms[bx]);
    8751068      ERR_PC_CLR(mrb);
     1069      regs[a] = val;
    8761070      NEXT;
    8771071    }
    8781072
    8791073    CASE(OP_SETCV) {
    880       /* cvset(Syms(Bx),R(A)) */
    881       mrb_vm_cv_set(mrb, syms[GETARG_Bx(i)], regs[GETARG_A(i)]);
     1074      /* A Bx   cvset(Syms(Bx),R(A)) */
     1075      int a = GETARG_A(i);
     1076      int bx = GETARG_Bx(i);
     1077      mrb_vm_cv_set(mrb, syms[bx], regs[a]);
    8821078      NEXT;
    8831079    }
    … …  
    8861082      /* A Bx    R(A) := constget(Syms(Bx)) */
    8871083      mrb_value val;
     1084      int a = GETARG_A(i);
     1085      int bx = GETARG_Bx(i);
     1086      mrb_sym sym = syms[bx];
    8881087
    8891088      ERR_PC_SET(mrb, pc);
    890       val = mrb_vm_const_get(mrb, syms[GETARG_Bx(i)]);
     1089      val = mrb_vm_const_get(mrb, sym);
    8911090      ERR_PC_CLR(mrb);
    892       regs = mrb->c->stack;
    893       regs[GETARG_A(i)] = val;
     1091      regs[a] = val;
    8941092      NEXT;
    8951093    }
    … …  
    8971095    CASE(OP_SETCONST) {
    8981096      /* A Bx   constset(Syms(Bx),R(A)) */
    899       mrb_vm_const_set(mrb, syms[GETARG_Bx(i)], regs[GETARG_A(i)]);
     1097      int a = GETARG_A(i);
     1098      int bx = GETARG_Bx(i);
     1099      mrb_vm_const_set(mrb, syms[bx], regs[a]);
    9001100      NEXT;
    9011101    }
    … …  
    9051105      mrb_value val;
    9061106      int a = GETARG_A(i);
     1107      int bx = GETARG_Bx(i);
    9071108
    9081109      ERR_PC_SET(mrb, pc);
    909       val = mrb_const_get(mrb, regs[a], syms[GETARG_Bx(i)]);
     1110      val = mrb_const_get(mrb, regs[a], syms[bx]);
    9101111      ERR_PC_CLR(mrb);
    911       regs = mrb->c->stack;
    9121112      regs[a] = val;
    9131113      NEXT;
    … …  
    9171117      /* A Bx    R(A+1)::Syms(Bx) := R(A) */
    9181118      int a = GETARG_A(i);
    919 
    920       mrb_const_set(mrb, regs[a+1], syms[GETARG_Bx(i)], regs[a]);
     1119      int bx = GETARG_Bx(i);
     1120      mrb_const_set(mrb, regs[a+1], syms[bx], regs[a]);
    9211121      NEXT;
    9221122    }
    … …  
    9241124    CASE(OP_GETUPVAR) {
    9251125      /* A B C  R(A) := uvget(B,C) */
    926       mrb_value *regs_a = regs + GETARG_A(i);
    927       int up = GETARG_C(i);
    928 
    929       struct REnv *e = uvenv(mrb, up);
     1126      int a = GETARG_A(i);
     1127      int b = GETARG_B(i);
     1128      int c = GETARG_C(i);
     1129      mrb_value *regs_a = regs + a;
     1130      struct REnv *e = uvenv(mrb, c);
    9301131
    9311132      if (!e) {
    … …  
    9331134      }
    9341135      else {
    935         int idx = GETARG_B(i);
    936         *regs_a = e->stack[idx];
     1136        *regs_a = e->stack[b];
    9371137      }
    9381138      NEXT;
    … …  
    9411141    CASE(OP_SETUPVAR) {
    9421142      /* A B C  uvset(B,C,R(A)) */
    943       int up = GETARG_C(i);
    944 
    945       struct REnv *e = uvenv(mrb, up);
     1143      int a = GETARG_A(i);
     1144      int b = GETARG_B(i);
     1145      int c = GETARG_C(i);
     1146
     1147      struct REnv *e = uvenv(mrb, c);
    9461148
    9471149      if (e) {
    948         mrb_value *regs_a = regs + GETARG_A(i);
    949         int idx = GETARG_B(i);
    950         e->stack[idx] = *regs_a;
    951         mrb_write_barrier(mrb, (struct RBasic*)e);
     1150        mrb_value *regs_a = regs + a;
     1151
     1152        if (b < MRB_ENV_STACK_LEN(e)) {
     1153          e->stack[b] = *regs_a;
     1154          mrb_write_barrier(mrb, (struct RBasic*)e);
     1155        }
    9521156      }
    9531157      NEXT;
    … …  
    9561160    CASE(OP_JMP) {
    9571161      /* sBx    pc+=sBx */
    958       pc += GETARG_sBx(i);
     1162      int sbx = GETARG_sBx(i);
     1163      pc += sbx;
    9591164      JUMP;
    9601165    }
    … …  
    9621167    CASE(OP_JMPIF) {
    9631168      /* A sBx  if R(A) pc+=sBx */
    964       if (mrb_test(regs[GETARG_A(i)])) {
    965         pc += GETARG_sBx(i);
     1169      int a = GETARG_A(i);
     1170      int sbx = GETARG_sBx(i);
     1171      if (mrb_test(regs[a])) {
     1172        pc += sbx;
    9661173        JUMP;
    9671174      }
    … …  
    9711178    CASE(OP_JMPNOT) {
    9721179      /* A sBx  if !R(A) pc+=sBx */
    973       if (!mrb_test(regs[GETARG_A(i)])) {
    974         pc += GETARG_sBx(i);
     1180      int a = GETARG_A(i);
     1181      int sbx = GETARG_sBx(i);
     1182      if (!mrb_test(regs[a])) {
     1183        pc += sbx;
    9751184        JUMP;
    9761185      }
    … …  
    9801189    CASE(OP_ONERR) {
    9811190      /* sBx    pc+=sBx on exception */
     1191      int sbx = GETARG_sBx(i);
    9821192      if (mrb->c->rsize <= mrb->c->ci->ridx) {
    983         if (mrb->c->rsize == 0) mrb->c->rsize = 16;
     1193        if (mrb->c->rsize == 0) mrb->c->rsize = RESCUE_STACK_INIT_SIZE;
    9841194        else mrb->c->rsize *= 2;
    9851195        mrb->c->rescue = (mrb_code **)mrb_realloc(mrb, mrb->c->rescue, sizeof(mrb_code*) * mrb->c->rsize);
    9861196      }
    987       mrb->c->rescue[mrb->c->ci->ridx++] = pc + GETARG_sBx(i);
     1197      mrb->c->rescue[mrb->c->ci->ridx++] = pc + sbx;
    9881198      NEXT;
    9891199    }
    9901200
    9911201    CASE(OP_RESCUE) {
    992       /* A      R(A) := exc; clear(exc) */
    993       SET_OBJ_VALUE(regs[GETARG_A(i)], mrb->exc);
    994       mrb->exc = 0;
     1202      /* A B    R(A) := exc; clear(exc); R(B) := matched (bool) */
     1203      int a = GETARG_A(i);
     1204      int b = GETARG_B(i);
     1205      int c = GETARG_C(i);
     1206      mrb_value exc;
     1207
     1208      if (c == 0) {
     1209        exc = mrb_obj_value(mrb->exc);
     1210        mrb->exc = 0;
     1211      }
     1212      else {           /* continued; exc taken from R(A) */
     1213        exc = regs[a];
     1214      }
     1215      if (b != 0) {
     1216        mrb_value e = regs[b];
     1217        struct RClass *ec;
     1218
     1219        switch (mrb_type(e)) {
     1220        case MRB_TT_CLASS:
     1221        case MRB_TT_MODULE:
     1222          break;
     1223        default:
     1224          {
     1225            mrb_value exc;
     1226
     1227            exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR,
     1228                  "class or module required for rescue clause");
     1229            mrb_exc_set(mrb, exc);
     1230            goto L_RAISE;
     1231          }
     1232        }
     1233        ec = mrb_class_ptr(e);
     1234        regs[b] = mrb_bool_value(mrb_obj_is_kind_of(mrb, exc, ec));
     1235      }
     1236      if (a != 0 && c == 0) {
     1237        regs[a] = exc;
     1238      }
    9951239      NEXT;
    9961240    }
    … …  
    10081252    CASE(OP_RAISE) {
    10091253      /* A      raise(R(A)) */
    1010       mrb->exc = mrb_obj_ptr(regs[GETARG_A(i)]);
     1254      int a = GETARG_A(i);
     1255
     1256      mrb_exc_set(mrb, regs[a]);
    10111257      goto L_RAISE;
    10121258    }
    … …  
    10141260    CASE(OP_EPUSH) {
    10151261      /* Bx     ensure_push(SEQ[Bx]) */
     1262      int bx = GETARG_Bx(i);
    10161263      struct RProc *p;
    10171264
    1018       p = mrb_closure_new(mrb, irep->reps[GETARG_Bx(i)]);
     1265      p = mrb_closure_new(mrb, irep->reps[bx]);
    10191266      /* push ensure_stack */
    1020       if (mrb->c->esize <= mrb->c->ci->eidx) {
    1021         if (mrb->c->esize == 0) mrb->c->esize = 16;
     1267      if (mrb->c->esize <= mrb->c->eidx+1) {
     1268        if (mrb->c->esize == 0) mrb->c->esize = ENSURE_STACK_INIT_SIZE;
    10221269        else mrb->c->esize *= 2;
    10231270        mrb->c->ensure = (struct RProc **)mrb_realloc(mrb, mrb->c->ensure, sizeof(struct RProc*) * mrb->c->esize);
    10241271      }
    1025       mrb->c->ensure[mrb->c->ci->eidx++] = p;
     1272      mrb->c->ensure[mrb->c->eidx++] = p;
     1273      mrb->c->ensure[mrb->c->eidx] = NULL;
    10261274      ARENA_RESTORE(mrb, ai);
    10271275      NEXT;
    … …  
    10321280      int a = GETARG_A(i);
    10331281      mrb_callinfo *ci = mrb->c->ci;
    1034       int n, eidx = ci->eidx;
    1035 
    1036       for (n=0; n<a && (ci == mrb->c->cibase || eidx > ci[-1].eidx); n++) {
    1037         ecall(mrb, --eidx);
     1282      int n, epos = ci->epos;
     1283
     1284      for (n=0; n<a && mrb->c->eidx > epos; n++) {
     1285        ecall(mrb, --mrb->c->eidx);
    10381286        ARENA_RESTORE(mrb, ai);
    10391287      }
    … …  
    10611309      struct RProc *m;
    10621310      struct RClass *c;
    1063       mrb_callinfo *ci;
     1311      mrb_callinfo *ci = mrb->c->ci;
    10641312      mrb_value recv, result;
    10651313      mrb_sym mid = syms[GETARG_B(i)];
     1314      int bidx;
     1315      mrb_value blk;
    10661316
    10671317      recv = regs[a];
     1318      if (n == CALL_MAXARGS) {
     1319        bidx = a+2;
     1320      }
     1321      else {
     1322        bidx = a+n+1;
     1323      }
    10681324      if (GET_OPCODE(i) != OP_SENDB) {
    1069         if (n == CALL_MAXARGS) {
    1070           SET_NIL_VALUE(regs[a+2]);
    1071         }
    1072         else {
    1073           SET_NIL_VALUE(regs[a+n+1]);
     1325        if (bidx >= ci->nregs) {
     1326          stack_extend(mrb, bidx+1);
     1327          ci->nregs = bidx+1;
     1328        }
     1329        SET_NIL_VALUE(regs[bidx]);
     1330        blk = mrb_nil_value();
     1331      }
     1332      else {
     1333        blk = regs[bidx];
     1334        if (!mrb_nil_p(blk) && mrb_type(blk) != MRB_TT_PROC) {
     1335          if (bidx >= ci->nregs) {
     1336            stack_extend(mrb, bidx+1);
     1337            ci->nregs = bidx+1;
     1338          }
     1339          result = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc");
     1340          blk = regs[bidx] = result;
    10741341        }
    10751342      }
    … …  
    10901357            args = mrb_ary_new_from_values(mrb, n, regs+a+1);
    10911358          }
     1359          ERR_PC_SET(mrb, pc);
    10921360          mrb_method_missing(mrb, mid, recv, args);
    10931361        }
    10941362        mid = missing;
    1095         if (n == CALL_MAXARGS) {
    1096           mrb_ary_unshift(mrb, regs[a+1], sym);
    1097         }
    1098         else {
    1099           value_move(regs+a+2, regs+a+1, ++n);
    1100           regs[a+1] = sym;
    1101         }
     1363        if (n != CALL_MAXARGS) {
     1364          if (a+2 >= irep->nregs) {
     1365            stack_extend(mrb, a+3);
     1366          }
     1367          regs[a+1] = mrb_ary_new_from_values(mrb, n, regs+a+1);
     1368          regs[a+2] = blk;
     1369          n = CALL_MAXARGS;
     1370        }
     1371        mrb_ary_unshift(mrb, regs[a+1], sym);
    11021372      }
    11031373
    … …  
    11251395        }
    11261396        result = m->body.func(mrb, recv);
    1127         mrb->c->stack[0] = result;
    11281397        mrb_gc_arena_restore(mrb, ai);
    11291398        if (mrb->exc) goto L_RAISE;
    1130         /* pop stackpos */
    11311399        ci = mrb->c->ci;
     1400        if (GET_OPCODE(i) == OP_SENDB) {
     1401          if (mrb_type(blk) == MRB_TT_PROC) {
     1402            struct RProc *p = mrb_proc_ptr(blk);
     1403
     1404            if (p && !MRB_PROC_STRICT_P(p) && p->env == ci[-1].env) {
     1405              p->flags |= MRB_PROC_ORPHAN;
     1406            }
     1407          }
     1408        }
    11321409        if (!ci->target_class) { /* return from context modifying method (resume/yield) */
    1133           if (!MRB_PROC_CFUNC_P(ci[-1].proc)) {
     1410          if (ci->acc == CI_ACC_RESUMED) {
     1411            mrb->jmp = prev_jmp;
     1412            return result;
     1413          }
     1414          else {
     1415            mrb_assert(!MRB_PROC_CFUNC_P(ci[-1].proc));
    11341416            proc = ci[-1].proc;
    11351417            irep = proc->body.irep;
    … …  
    11381420          }
    11391421        }
    1140         regs = mrb->c->stack = ci->stackent;
     1422        mrb->c->stack[0] = result;
     1423        /* pop stackpos */
     1424        mrb->c->stack = ci->stackent;
    11411425        pc = ci->pc;
    11421426        cipop(mrb);
    … …  
    11521436        if (n == CALL_MAXARGS) {
    11531437          ci->argc = -1;
    1154           stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
     1438          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs);
    11551439        }
    11561440        else {
    11571441          ci->argc = n;
    1158           stack_extend(mrb, irep->nregs,  n+2);
    1159         }
    1160         regs = mrb->c->stack;
     1442          stack_extend(mrb, irep->nregs);
     1443        }
    11611444        pc = irep->iseq;
    11621445        JUMP;
    … …  
    11661449    CASE(OP_FSEND) {
    11671450      /* A B C  R(A) := fcall(R(A),Syms(B),R(A+1),... ,R(A+C-1)) */
     1451      /* not implemented yet */
    11681452      NEXT;
    11691453    }
    … …  
    11801464      ci->proc = m;
    11811465      if (m->env) {
    1182         if (m->env->mid) {
    1183           ci->mid = m->env->mid;
    1184         }
     1466        mrb_sym mid;
     1467
     1468        if (MRB_ENV_STACK_SHARED_P(m->env)) {
     1469          mid = m->env->cxt.c->cibase[m->env->cioff].mid;
     1470        }
     1471        else {
     1472          mid = m->env->cxt.mid;
     1473        }
     1474        if (mid) ci->mid = mid;
    11851475        if (!m->env->stack) {
    11861476          m->env->stack = mrb->c->stack;
    … …  
    11951485        /* pop stackpos */
    11961486        ci = mrb->c->ci;
    1197         regs = mrb->c->stack = ci->stackent;
     1487        mrb->c->stack = ci->stackent;
    11981488        regs[ci->acc] = recv;
    11991489        pc = ci->pc;
    … …  
    12151505        syms = irep->syms;
    12161506        ci->nregs = irep->nregs;
     1507        stack_extend(mrb, irep->nregs);
    12171508        if (ci->argc < 0) {
    1218           stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
    1219         }
    1220         else {
    1221           stack_extend(mrb, irep->nregs, ci->argc+2);
    1222         }
    1223         regs = mrb->c->stack;
    1224         regs[0] = m->env->stack[0];
     1509          if (irep->nregs > 3) {
     1510            stack_clear(regs+3, irep->nregs-3);
     1511          }
     1512        }
     1513        else if (ci->argc+2 < irep->nregs) {
     1514          stack_clear(regs+ci->argc+2, irep->nregs-ci->argc-2);
     1515        }
     1516        if (m->env) {
     1517          regs[0] = m->env->stack[0];
     1518        }
    12251519        pc = irep->iseq;
    12261520        JUMP;
    … …  
    12371531      int a = GETARG_A(i);
    12381532      int n = GETARG_C(i);
    1239 
    1240       if (mid == 0) {
     1533      mrb_value blk;
     1534      int bidx;
     1535
     1536      if (mid == 0 || !ci->target_class) {
    12411537        mrb_value exc;
    12421538
    12431539        exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
    1244         mrb->exc = mrb_obj_ptr(exc);
     1540        mrb_exc_set(mrb, exc);
    12451541        goto L_RAISE;
    12461542      }
    … …  
    12491545      m = mrb_method_search_vm(mrb, &c, mid);
    12501546      if (!m) {
    1251         mid = mrb_intern_lit(mrb, "method_missing");
    1252         m = mrb_method_search_vm(mrb, &c, mid);
     1547        mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
     1548        m = mrb_method_search_vm(mrb, &c, missing);
     1549        if (!m) {
     1550          mrb_value args;
     1551
     1552          if (n == CALL_MAXARGS) {
     1553            args = regs[a+1];
     1554          }
     1555          else {
     1556            args = mrb_ary_new_from_values(mrb, n, regs+a+1);
     1557          }
     1558          ERR_PC_SET(mrb, pc);
     1559          mrb_method_missing(mrb, mid, recv, args);
     1560        }
     1561        mid = missing;
     1562        if (n == CALL_MAXARGS-1) {
     1563          regs[a+1] = mrb_ary_new_from_values(mrb, n, regs+a+1);
     1564          n++;
     1565        }
    12531566        if (n == CALL_MAXARGS) {
    12541567          mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid));
    … …  
    12581571          SET_SYM_VALUE(regs[a+1], ci->mid);
    12591572        }
     1573      }
     1574
     1575      if (n == CALL_MAXARGS) {
     1576        bidx = a+2;
     1577      }
     1578      else {
     1579        bidx = a+n+1;
     1580      }
     1581      blk = regs[bidx];
     1582      if (!mrb_nil_p(blk) && mrb_type(blk) != MRB_TT_PROC) {
     1583        mrb_value result;
     1584
     1585        if (bidx >= ci->nregs) {
     1586          stack_extend(mrb, bidx+1);
     1587          ci->nregs = bidx+1;
     1588        }
     1589        result = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc");
     1590        regs[bidx] = result;
    12601591      }
    12611592
    … …  
    12651596      ci->proc = m;
    12661597      ci->stackent = mrb->c->stack;
     1598      ci->target_class = c;
     1599      ci->pc = pc + 1;
    12671600      if (n == CALL_MAXARGS) {
    12681601        ci->argc = -1;
    … …  
    12711604        ci->argc = n;
    12721605      }
    1273       ci->target_class = c;
    1274       ci->pc = pc + 1;
    12751606
    12761607      /* prepare stack */
    … …  
    12791610
    12801611      if (MRB_PROC_CFUNC_P(m)) {
     1612        mrb_value v;
     1613
    12811614        if (n == CALL_MAXARGS) {
    12821615          ci->nregs = 3;
    … …  
    12851618          ci->nregs = n + 2;
    12861619        }
    1287         mrb->c->stack[0] = m->body.func(mrb, recv);
     1620        v = m->body.func(mrb, recv);
    12881621        mrb_gc_arena_restore(mrb, ai);
    12891622        if (mrb->exc) goto L_RAISE;
     1623        ci = mrb->c->ci;
     1624        if (!ci->target_class) { /* return from context modifying method (resume/yield) */
     1625          if (ci->acc == CI_ACC_RESUMED) {
     1626            mrb->jmp = prev_jmp;
     1627            return v;
     1628          }
     1629          else {
     1630            mrb_assert(!MRB_PROC_CFUNC_P(ci[-1].proc));
     1631            proc = ci[-1].proc;
     1632            irep = proc->body.irep;
     1633            pool = irep->pool;
     1634            syms = irep->syms;
     1635          }
     1636        }
     1637        mrb->c->stack[0] = v;
    12901638        /* pop stackpos */
    1291         regs = mrb->c->stack = mrb->c->ci->stackent;
     1639        mrb->c->stack = ci->stackent;
     1640        pc = ci->pc;
    12921641        cipop(mrb);
    1293         NEXT;
     1642        JUMP;
    12941643      }
    12951644      else {
    … …  
    13041653        ci->nregs = irep->nregs;
    13051654        if (n == CALL_MAXARGS) {
    1306           stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
     1655          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs);
    13071656        }
    13081657        else {
    1309           stack_extend(mrb, irep->nregs, ci->argc+2);
    1310         }
    1311         regs = mrb->c->stack;
     1658          stack_extend(mrb, irep->nregs);
     1659        }
    13121660        pc = irep->iseq;
    13131661        JUMP;
    … …  
    13251673      mrb_value *stack;
    13261674
     1675      if (mrb->c->ci->mid == 0 || mrb->c->ci->target_class == NULL) {
     1676        mrb_value exc;
     1677
     1678      L_NOSUPER:
     1679        exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
     1680        mrb_exc_set(mrb, exc);
     1681        goto L_RAISE;
     1682      }
    13271683      if (lv == 0) stack = regs + 1;
    13281684      else {
    13291685        struct REnv *e = uvenv(mrb, lv-1);
    1330         if (!e) {
    1331           mrb_value exc;
    1332 
    1333           exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
    1334           mrb->exc = mrb_obj_ptr(exc);
    1335           goto L_RAISE;
    1336         }
     1686        if (!e) goto L_NOSUPER;
    13371687        stack = e->stack + 1;
    13381688      }
    … …  
    13881738      mrb_value *blk = &argv[argc < 0 ? 1 : argc];
    13891739
    1390       if (!mrb_nil_p(*blk) && mrb_type(*blk) != MRB_TT_PROC) {
    1391         *blk = mrb_convert_type(mrb, *blk, MRB_TT_PROC, "Proc", "to_proc");
    1392       }
    13931740      if (argc < 0) {
    13941741        struct RArray *ary = mrb_ary_ptr(regs[1]);
    … …  
    14101757        argv = mrb_ary_ptr(argv[0])->ptr;
    14111758      }
    1412       mrb->c->ci->argc = len;
    14131759      if (argc < len) {
    14141760        int mlen = m2;
    … …  
    14241770          value_move(&regs[1], argv, argc-mlen); /* m1 + o */
    14251771        }
     1772        if (argc < m1) {
     1773          stack_clear(&regs[argc+1], m1-argc);
     1774        }
    14261775        if (mlen) {
    14271776          value_move(&regs[len-m2+1], &argv[argc-mlen], mlen);
     1777        }
     1778        if (mlen < m2) {
     1779          stack_clear(&regs[len-m2+mlen+1], m2-mlen);
    14281780        }
    14291781        if (r) {
    … …  
    14541806        pc += o + 1;
    14551807      }
     1808      mrb->c->ci->argc = len;
     1809      /* clear local (but non-argument) variables */
     1810      if (irep->nlocals-len-2 > 0) {
     1811        stack_clear(&regs[len+2], irep->nlocals-len-2);
     1812      }
    14561813      JUMP;
    14571814    }
    … …  
    14741831    CASE(OP_RETURN) {
    14751832      /* A B     return R(A) (B=normal,in-block return/break) */
     1833      mrb_callinfo *ci;
     1834
     1835      ci = mrb->c->ci;
     1836      if (ci->mid) {
     1837        mrb_value blk;
     1838
     1839        if (ci->argc < 0) {
     1840          blk = regs[2];
     1841        }
     1842        else {
     1843          blk = regs[ci->argc+1];
     1844        }
     1845        if (mrb_type(blk) == MRB_TT_PROC) {
     1846          struct RProc *p = mrb_proc_ptr(blk);
     1847
     1848          if (!MRB_PROC_STRICT_P(proc) &&
     1849              ci > mrb->c->cibase && p->env == ci[-1].env) {
     1850            p->flags |= MRB_PROC_ORPHAN;
     1851          }
     1852        }
     1853      }
     1854
    14761855      if (mrb->exc) {
    1477         mrb_callinfo *ci;
    1478         int eidx;
     1856        mrb_callinfo *ci0;
     1857        mrb_value *stk;
    14791858
    14801859      L_RAISE:
    1481         ci = mrb->c->ci;
    1482         mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern_lit(mrb, "lastpc"), mrb_cptr_value(mrb, pc));
    1483         mrb_obj_iv_ifnone(mrb, mrb->exc, mrb_intern_lit(mrb, "ciidx"), mrb_fixnum_value(ci - mrb->c->cibase));
    1484         eidx = ci->eidx;
     1860        ci0 = ci = mrb->c->ci;
    14851861        if (ci == mrb->c->cibase) {
    1486           if (ci->ridx == 0) goto L_STOP;
     1862          if (ci->ridx == 0) goto L_FTOP;
    14871863          goto L_RESCUE;
    14881864        }
     1865        stk = mrb->c->stack;
    14891866        while (ci[0].ridx == ci[-1].ridx) {
    14901867          cipop(mrb);
    1491           ci = mrb->c->ci;
    1492           mrb->c->stack = ci[1].stackent;
    1493           if (ci[1].acc == CI_ACC_SKIP && prev_jmp) {
     1868          mrb->c->stack = ci->stackent;
     1869          if (ci->acc == CI_ACC_SKIP && prev_jmp) {
    14941870            mrb->jmp = prev_jmp;
    14951871            MRB_THROW(prev_jmp);
    14961872          }
     1873          ci = mrb->c->ci;
    14971874          if (ci == mrb->c->cibase) {
    1498             while (eidx > 0) {
    1499               ecall(mrb, --eidx);
    1500             }
     1875            mrb->c->stack = stk;
    15011876            if (ci->ridx == 0) {
     1877            L_FTOP:             /* fiber top */
    15021878              if (mrb->c == mrb->root_c) {
    1503                 regs = mrb->c->stack = mrb->c->stbase;
     1879                mrb->c->stack = mrb->c->stbase;
    15041880                goto L_STOP;
    15051881              }
    … …  
    15071883                struct mrb_context *c = mrb->c;
    15081884
     1885                if (c->fib) {
     1886                  mrb_write_barrier(mrb, (struct RBasic*)c->fib);
     1887                }
    15091888                mrb->c = c->prev;
    15101889                c->prev = NULL;
    … …  
    15161895          /* call ensure only when we skip this callinfo */
    15171896          if (ci[0].ridx == ci[-1].ridx) {
    1518             while (eidx > ci[-1].eidx) {
    1519               ecall(mrb, --eidx);
     1897            while (mrb->c->eidx > ci->epos) {
     1898              ecall(mrb, --mrb->c->eidx);
     1899              ci = mrb->c->ci;
    15201900            }
    15211901          }
    … …  
    15271907        pool = irep->pool;
    15281908        syms = irep->syms;
    1529         regs = mrb->c->stack = ci[1].stackent;
     1909        if (ci != ci0) {
     1910          mrb->c->stack = ci[1].stackent;
     1911        }
     1912        stack_extend(mrb, irep->nregs);
    15301913        pc = mrb->c->rescue[--ci->ridx];
    15311914      }
    15321915      else {
    1533         mrb_callinfo *ci = mrb->c->ci;
    1534         int acc, eidx = mrb->c->ci->eidx;
    1535         mrb_value v = regs[GETARG_A(i)];
    1536 
     1916        int acc;
     1917        mrb_value v;
     1918
     1919        v = regs[GETARG_A(i)];
     1920        mrb_gc_protect(mrb, v);
    15371921        switch (GETARG_B(i)) {
    15381922        case OP_R_RETURN:
    15391923          /* Fall through to OP_R_NORMAL otherwise */
    1540           if (proc->env && !MRB_PROC_STRICT_P(proc)) {
     1924          if (ci->acc >=0 && proc->env && !MRB_PROC_STRICT_P(proc)) {
    15411925            struct REnv *e = top_env(mrb, proc);
    1542 
    1543             if (!MRB_ENV_STACK_SHARED_P(e)) {
     1926            mrb_callinfo *ce;
     1927
     1928            if (!MRB_ENV_STACK_SHARED_P(e) || e->cxt.c != mrb->c) {
    15441929              localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
    15451930              goto L_RAISE;
    15461931            }
    1547             ci = mrb->c->cibase + e->cioff;
    1548             if (ci == mrb->c->cibase) {
     1932           
     1933            ce = mrb->c->cibase + e->cioff;
     1934            while (ci >= ce) {
     1935              if (ci->env) {
     1936                mrb_env_unshare(mrb, ci->env);
     1937              }
     1938              if (ci->acc < 0) {
     1939                localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
     1940                goto L_RAISE;
     1941              }
     1942              ci--;
     1943            }
     1944            if (ce == mrb->c->cibase) {
    15491945              localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
    15501946              goto L_RAISE;
    15511947            }
    15521948            mrb->c->stack = mrb->c->ci->stackent;
    1553             mrb->c->ci = ci;
     1949            mrb->c->ci = ce;
    15541950            break;
    15551951          }
    15561952        case OP_R_NORMAL:
     1953        NORMAL_RETURN:
    15571954          if (ci == mrb->c->cibase) {
    15581955            if (!mrb->c->prev) { /* toplevel return */
    … …  
    15621959            if (mrb->c->prev->ci == mrb->c->prev->cibase) {
    15631960              mrb_value exc = mrb_exc_new_str_lit(mrb, E_FIBER_ERROR, "double resume");
    1564               mrb->exc = mrb_obj_ptr(exc);
     1961              mrb_exc_set(mrb, exc);
    15651962              goto L_RAISE;
     1963            }
     1964            while (mrb->c->eidx > 0) {
     1965              ecall(mrb, --mrb->c->eidx);
    15661966            }
    15671967            /* automatic yield at the end */
    … …  
    15731973          break;
    15741974        case OP_R_BREAK:
     1975          if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN;
     1976          if (MRB_PROC_ORPHAN_P(proc)) {
     1977            mrb_value exc;
     1978
     1979          L_BREAK_ERROR:
     1980            exc = mrb_exc_new_str_lit(mrb, E_LOCALJUMP_ERROR,
     1981                                      "break from proc-closure");
     1982            mrb_exc_set(mrb, exc);
     1983            goto L_RAISE;
     1984          }
    15751985          if (!proc->env || !MRB_ENV_STACK_SHARED_P(proc->env)) {
    1576             localjump_error(mrb, LOCALJUMP_ERROR_BREAK);
    1577             goto L_RAISE;
     1986            goto L_BREAK_ERROR;
    15781987          }
    15791988          /* break from fiber block */
    … …  
    15811990            struct mrb_context *c = mrb->c;
    15821991
     1992            while (mrb->c->eidx > 0) {
     1993              ecall(mrb, --mrb->c->eidx);
     1994            }
    15831995            mrb->c = c->prev;
    15841996            c->prev = NULL;
    1585           }
    1586           ci = mrb->c->ci;
     1997            ci = mrb->c->ci;
     1998          }
     1999          if (ci->acc < 0) {
     2000            while (mrb->c->eidx > mrb->c->ci->epos) {
     2001              ecall(mrb, --mrb->c->eidx);
     2002            }
     2003            ARENA_RESTORE(mrb, ai);
     2004            mrb->c->vmexec = FALSE;
     2005            mrb->exc = (struct RObject*)break_new(mrb, proc, v);
     2006            mrb->jmp = prev_jmp;
     2007            MRB_THROW(prev_jmp);
     2008          }
     2009          if (FALSE) {
     2010          L_BREAK:
     2011            v = ((struct RBreak*)mrb->exc)->val;
     2012            proc = ((struct RBreak*)mrb->exc)->proc;
     2013            mrb->exc = NULL;
     2014            ci = mrb->c->ci;
     2015          }
    15872016          mrb->c->stack = ci->stackent;
    15882017          mrb->c->ci = mrb->c->cibase + proc->env->cioff + 1;
    15892018          while (ci > mrb->c->ci) {
     2019            if (ci->env) {
     2020              mrb_env_unshare(mrb, ci->env);
     2021            }
    15902022            if (ci[-1].acc == CI_ACC_SKIP) {
    15912023              mrb->c->ci = ci;
    1592               break;
     2024              goto L_BREAK_ERROR;
    15932025            }
    15942026            ci--;
    … …  
    15992031          break;
    16002032        }
    1601         while (eidx > mrb->c->ci[-1].eidx) {
    1602           ecall(mrb, --eidx);
    1603         }
    1604         cipop(mrb);
    1605         acc = ci->acc;
    1606         pc = ci->pc;
    1607         regs = mrb->c->stack = ci->stackent;
    1608         if (acc == CI_ACC_SKIP) {
     2033        while (mrb->c->eidx > mrb->c->ci->epos) {
     2034          ecall(mrb, --mrb->c->eidx);
     2035        }
     2036        if (mrb->c->vmexec && !mrb->c->ci->target_class) {
     2037          ARENA_RESTORE(mrb, ai);
     2038          mrb->c->vmexec = FALSE;
    16092039          mrb->jmp = prev_jmp;
    16102040          return v;
    16112041        }
    1612         DEBUG(printf("from :%s\n", mrb_sym2name(mrb, ci->mid)));
     2042        ci = mrb->c->ci;
     2043        acc = ci->acc;
     2044        mrb->c->stack = ci->stackent;
     2045        cipop(mrb);
     2046        if (acc == CI_ACC_SKIP || acc == CI_ACC_DIRECT) {
     2047          ARENA_RESTORE(mrb, ai);
     2048          mrb->jmp = prev_jmp;
     2049          return v;
     2050        }
     2051        pc = ci->pc;
     2052        DEBUG(fprintf(stderr, "from :%s\n", mrb_sym2name(mrb, ci->mid)));
    16132053        proc = mrb->c->ci->proc;
    16142054        irep = proc->body.irep;
    … …  
    16172057
    16182058        regs[acc] = v;
     2059        ARENA_RESTORE(mrb, ai);
    16192060      }
    16202061      JUMP;
    … …  
    16362077      if (!m) {
    16372078        mrb_value sym = mrb_symbol_value(mid);
    1638 
    1639         mid = mrb_intern_lit(mrb, "method_missing");
    1640         m = mrb_method_search_vm(mrb, &c, mid);
     2079        mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
     2080        m = mrb_method_search_vm(mrb, &c, missing);
     2081        if (!m) {
     2082          mrb_value args;
     2083
     2084          if (n == CALL_MAXARGS) {
     2085            args = regs[a+1];
     2086          }
     2087          else {
     2088            args = mrb_ary_new_from_values(mrb, n, regs+a+1);
     2089          }
     2090          ERR_PC_SET(mrb, pc);
     2091          mrb_method_missing(mrb, mid, recv, args);
     2092        }
     2093        mid = missing;
    16412094        if (n == CALL_MAXARGS) {
    16422095          mrb_ary_unshift(mrb, regs[a+1], sym);
    … …  
    16632116
    16642117      if (MRB_PROC_CFUNC_P(m)) {
    1665         mrb->c->stack[0] = m->body.func(mrb, recv);
     2118        mrb_value v = m->body.func(mrb, recv);
     2119        mrb->c->stack[0] = v;
    16662120        mrb_gc_arena_restore(mrb, ai);
    16672121        goto L_RETURN;
    … …  
    16732127        syms = irep->syms;
    16742128        if (ci->argc < 0) {
    1675           stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
     2129          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs);
    16762130        }
    16772131        else {
    1678           stack_extend(mrb, irep->nregs, ci->argc+2);
    1679         }
    1680         regs = mrb->c->stack;
     2132          stack_extend(mrb, irep->nregs);
     2133        }
    16812134        pc = irep->iseq;
    16822135      }
    … …  
    16972150      else {
    16982151        struct REnv *e = uvenv(mrb, lv-1);
    1699         if (!e) {
     2152        if (!e || e->cioff == 0 ||
     2153            (!MRB_ENV_STACK_SHARED_P(e) && e->cxt.mid == 0)) {
    17002154          localjump_error(mrb, LOCALJUMP_ERROR_YIELD);
    17012155          goto L_RAISE;
    17022156        }
    17032157        stack = e->stack + 1;
     2158      }
     2159      if (mrb_nil_p(stack[m1+r+m2])) {
     2160        localjump_error(mrb, LOCALJUMP_ERROR_YIELD);
     2161        goto L_RAISE;
    17042162      }
    17052163      regs[a] = stack[m1+r+m2];
    … …  
    18332291      case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
    18342292        {
    1835           mrb_value z;
    1836 
    1837           z = mrb_fixnum_mul(mrb, regs[a], regs[a+1]);
    1838 
    1839           switch (mrb_type(z)) {
    1840           case MRB_TT_FIXNUM:
    1841             {
    1842               SET_INT_VALUE(regs[a], mrb_fixnum(z));
    1843             }
     2293          mrb_int x, y, z;
     2294
     2295          x = mrb_fixnum(regs[a]);
     2296          y = mrb_fixnum(regs[a+1]);
     2297          if (mrb_int_mul_overflow(x, y, &z)) {
     2298            SET_FLOAT_VALUE(mrb, regs[a], (mrb_float)x * (mrb_float)y);
    18442299            break;
    1845           case MRB_TT_FLOAT:
    1846             {
    1847               SET_FLOAT_VALUE(mrb, regs[a], mrb_float(z));
    1848             }
    1849             break;
    1850           default:
    1851             /* cannot happen */
    1852             break;
    1853           }
     2300          }
     2301          SET_INT_VALUE(regs[a], z);
    18542302        }
    18552303        break;
    … …  
    19362384#ifdef MRB_NAN_BOXING
    19372385      if (isnan(mrb_float(regs[a]))) {
    1938         regs[a] = mrb_float_value(mrb, mrb_float(regs[a]));
     2386        mrb_value v = mrb_float_value(mrb, mrb_float(regs[a]));
     2387        regs[a] = v;
    19392388      }
    19402389#endif
    … …  
    20892538    CASE(OP_ARRAY) {
    20902539      /* A B C          R(A) := ary_new(R(B),R(B+1)..R(B+C)) */
    2091       regs[GETARG_A(i)] = mrb_ary_new_from_values(mrb, GETARG_C(i), &regs[GETARG_B(i)]);
     2540      int a = GETARG_A(i);
     2541      int b = GETARG_B(i);
     2542      int c = GETARG_C(i);
     2543      mrb_value v = mrb_ary_new_from_values(mrb, c, &regs[b]);
     2544      regs[a] = v;
    20922545      ARENA_RESTORE(mrb, ai);
    20932546      NEXT;
    … …  
    20962549    CASE(OP_ARYCAT) {
    20972550      /* A B            mrb_ary_concat(R(A),R(B)) */
    2098       mrb_ary_concat(mrb, regs[GETARG_A(i)],
    2099                      mrb_ary_splat(mrb, regs[GETARG_B(i)]));
     2551      int a = GETARG_A(i);
     2552      int b = GETARG_B(i);
     2553      mrb_value splat = mrb_ary_splat(mrb, regs[b]);
     2554      mrb_ary_concat(mrb, regs[a], splat);
    21002555      ARENA_RESTORE(mrb, ai);
    21012556      NEXT;
    … …  
    21042559    CASE(OP_ARYPUSH) {
    21052560      /* A B            R(A).push(R(B)) */
    2106       mrb_ary_push(mrb, regs[GETARG_A(i)], regs[GETARG_B(i)]);
     2561      int a = GETARG_A(i);
     2562      int b = GETARG_B(i);
     2563      mrb_ary_push(mrb, regs[a], regs[b]);
    21072564      NEXT;
    21082565    }
    … …  
    21112568      /* A B C          R(A) := R(B)[C] */
    21122569      int a = GETARG_A(i);
     2570      int b = GETARG_B(i);
    21132571      int c = GETARG_C(i);
    2114       mrb_value v = regs[GETARG_B(i)];
     2572      mrb_value v = regs[b];
    21152573
    21162574      if (!mrb_array_p(v)) {
    21172575        if (c == 0) {
    2118           regs[GETARG_A(i)] = v;
     2576          regs[a] = v;
    21192577        }
    21202578        else {
    … …  
    21232581      }
    21242582      else {
    2125         regs[GETARG_A(i)] = mrb_ary_ref(mrb, v, c);
     2583        v = mrb_ary_ref(mrb, v, c);
     2584        regs[a] = v;
    21262585      }
    21272586      NEXT;
    … …  
    21302589    CASE(OP_ASET) {
    21312590      /* A B C          R(B)[C] := R(A) */
    2132       mrb_ary_set(mrb, regs[GETARG_B(i)], GETARG_C(i), regs[GETARG_A(i)]);
     2591      int a = GETARG_A(i);
     2592      int b = GETARG_B(i);
     2593      int c = GETARG_C(i);
     2594      mrb_ary_set(mrb, regs[b], c, regs[a]);
    21332595      NEXT;
    21342596    }
    … …  
    21402602      int pre  = GETARG_B(i);
    21412603      int post = GETARG_C(i);
    2142 
    21432604      struct RArray *ary;
    21442605      int len, idx;
    … …  
    21502611      len = ary->len;
    21512612      if (len > pre + post) {
    2152         regs[a++] = mrb_ary_new_from_values(mrb, len - pre - post, ary->ptr+pre);
     2613        v = mrb_ary_new_from_values(mrb, len - pre - post, ary->ptr+pre);
     2614        regs[a++] = v;
    21532615        while (post--) {
    21542616          regs[a++] = ary->ptr[len-post-1];
    … …  
    21562618      }
    21572619      else {
    2158         regs[a++] = mrb_ary_new_capa(mrb, 0);
     2620        v = mrb_ary_new_capa(mrb, 0);
     2621        regs[a++] = v;
    21592622        for (idx=0; idx+pre<len; idx++) {
    21602623          regs[a+idx] = ary->ptr[pre+idx];
    … …  
    21712634    CASE(OP_STRING) {
    21722635      /* A Bx           R(A) := str_new(Lit(Bx)) */
    2173       regs[GETARG_A(i)] = mrb_str_dup(mrb, pool[GETARG_Bx(i)]);
     2636      mrb_value str = mrb_str_dup(mrb, pool[GETARG_Bx(i)]);
     2637      regs[GETARG_A(i)] = str;
    21742638      ARENA_RESTORE(mrb, ai);
    21752639      NEXT;
    … …  
    21792643      /* A B    R(A).concat(R(B)) */
    21802644      mrb_str_concat(mrb, regs[GETARG_A(i)], regs[GETARG_B(i)]);
    2181       regs = mrb->c->stack;
    21822645      NEXT;
    21832646    }
    … …  
    22242687    CASE(OP_CLASS) {
    22252688      /* A B    R(A) := newclass(R(A),Syms(B),R(A+1)) */
    2226       struct RClass *c = 0;
     2689      struct RClass *c = 0, *baseclass;
    22272690      int a = GETARG_A(i);
    22282691      mrb_value base, super;
    … …  
    22322695      super = regs[a+1];
    22332696      if (mrb_nil_p(base)) {
    2234         base = mrb_obj_value(mrb->c->ci->target_class);
     2697        baseclass = mrb->c->ci->proc->target_class;
     2698        if (!baseclass) baseclass = mrb->c->ci->target_class;
     2699
     2700        base = mrb_obj_value(baseclass);
    22352701      }
    22362702      c = mrb_vm_define_class(mrb, base, super, id);
    … …  
    22422708    CASE(OP_MODULE) {
    22432709      /* A B            R(A) := newmodule(R(A),Syms(B)) */
    2244       struct RClass *c = 0;
     2710      struct RClass *c = 0, *baseclass;
    22452711      int a = GETARG_A(i);
    22462712      mrb_value base;
    … …  
    22492715      base = regs[a];
    22502716      if (mrb_nil_p(base)) {
    2251         base = mrb_obj_value(mrb->c->ci->target_class);
     2717        baseclass = mrb->c->ci->proc->target_class;
     2718        if (!baseclass) baseclass = mrb->c->ci->target_class;
     2719
     2720        base = mrb_obj_value(baseclass);
    22522721      }
    22532722      c = mrb_vm_define_module(mrb, base, id);
    … …  
    22632732      mrb_value recv = regs[a];
    22642733      struct RProc *p;
     2734
     2735      /* prepare closure */
     2736      p = mrb_closure_new(mrb, irep->reps[GETARG_Bx(i)]);
     2737      p->c = NULL;
    22652738
    22662739      /* prepare stack */
    … …  
    22762749      mrb->c->stack += a;
    22772750
    2278       p = mrb_proc_new(mrb, irep->reps[GETARG_Bx(i)]);
     2751      /* setup closure */
    22792752      p->target_class = ci->target_class;
    22802753      ci->proc = p;
    22812754
    2282       if (MRB_PROC_CFUNC_P(p)) {
    2283         ci->nregs = 0;
    2284         mrb->c->stack[0] = p->body.func(mrb, recv);
    2285         mrb_gc_arena_restore(mrb, ai);
    2286         if (mrb->exc) goto L_RAISE;
    2287         /* pop stackpos */
    2288         regs = mrb->c->stack = mrb->c->ci->stackent;
    2289         cipop(mrb);
    2290         NEXT;
    2291       }
    2292       else {
    2293         irep = p->body.irep;
    2294         pool = irep->pool;
    2295         syms = irep->syms;
    2296         stack_extend(mrb, irep->nregs, 1);
    2297         ci->nregs = irep->nregs;
    2298         regs = mrb->c->stack;
    2299         pc = irep->iseq;
    2300         JUMP;
    2301       }
     2755      irep = p->body.irep;
     2756      pool = irep->pool;
     2757      syms = irep->syms;
     2758      stack_extend(mrb, irep->nregs);
     2759      stack_clear(regs+1, irep->nregs-1);
     2760      ci->nregs = irep->nregs;
     2761      pc = irep->iseq;
     2762      JUMP;
    23022763    }
    23032764
    … …  
    23242785      if (!mrb->c->ci->target_class) {
    23252786        mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR, "no target class or module");
    2326         mrb->exc = mrb_obj_ptr(exc);
     2787        mrb_exc_set(mrb, exc);
    23272788        goto L_RAISE;
    23282789      }
    … …  
    23342795      /* A B C  R(A) := range_new(R(B),R(B+1),C) */
    23352796      int b = GETARG_B(i);
    2336       regs[GETARG_A(i)] = mrb_range_new(mrb, regs[b], regs[b+1], GETARG_C(i));
     2797      mrb_value val = mrb_range_new(mrb, regs[b], regs[b+1], GETARG_C(i));
     2798      regs[GETARG_A(i)] = val;
    23372799      ARENA_RESTORE(mrb, ai);
    23382800      NEXT;
    … …  
    23572819    L_STOP:
    23582820      {
    2359         int eidx_stop = mrb->c->ci == mrb->c->cibase ? 0 : mrb->c->ci[-1].eidx;
    2360         int eidx = mrb->c->ci->eidx;
    2361         while (eidx > eidx_stop) {
    2362           ecall(mrb, --eidx);
     2821        int epos = mrb->c->ci->epos;
     2822
     2823        while (mrb->c->eidx > epos) {
     2824          ecall(mrb, --mrb->c->eidx);
    23632825        }
    23642826      }
    … …  
    23822844        exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg);
    23832845      }
    2384       mrb->exc = mrb_obj_ptr(exc);
     2846      mrb_exc_set(mrb, exc);
    23852847      goto L_RAISE;
    23862848    }
    23872849  }
    23882850  END_DISPATCH;
     2851#undef regs
    23892852
    23902853  }
    … …  
    23992862mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
    24002863{
    2401   return mrb_context_run(mrb, proc, self, mrb->c->ci->argc + 2); /* argc + 2 (receiver and block) */
     2864  if (mrb->c->ci->argc < 0) {
     2865    return mrb_vm_run(mrb, proc, self, 3); /* receiver, args and block) */
     2866  }
     2867  else {
     2868    return mrb_vm_run(mrb, proc, self, mrb->c->ci->argc + 2); /* argc + 2 (receiver and block) */
     2869  }
    24022870}
    24032871
    24042872MRB_API mrb_value
    2405 mrb_toplevel_run_keep(mrb_state *mrb, struct RProc *proc, unsigned int stack_keep)
     2873mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
    24062874{
    24072875  mrb_callinfo *ci;
    24082876  mrb_value v;
    24092877
    2410   if (!mrb->c->cibase || mrb->c->ci == mrb->c->cibase) {
    2411     return mrb_context_run(mrb, proc, mrb_top_self(mrb), stack_keep);
     2878  if (!mrb->c->cibase) {
     2879    return mrb_vm_run(mrb, proc, self, stack_keep);
     2880  }
     2881  if (mrb->c->ci == mrb->c->cibase) {
     2882    mrb->c->ci->env = NULL;
     2883    return mrb_vm_run(mrb, proc, self, stack_keep);
    24122884  }
    24132885  ci = cipush(mrb);
     2886  ci->mid = 0;
    24142887  ci->nregs = 1;   /* protect the receiver */
    24152888  ci->acc = CI_ACC_SKIP;
    24162889  ci->target_class = mrb->object_class;
    2417   v = mrb_context_run(mrb, proc, mrb_top_self(mrb), stack_keep);
     2890  v = mrb_vm_run(mrb, proc, self, stack_keep);
    24182891  cipop(mrb);
    24192892
    … …  
    24212894}
    24222895
    2423 MRB_API mrb_value
    2424 mrb_toplevel_run(mrb_state *mrb, struct RProc *proc)
    2425 {
    2426   return mrb_toplevel_run_keep(mrb, proc, 0);
    2427 }
     2896#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
     2897# if !defined(MRB_ENABLE_CXX_ABI)
     2898} /* end of extern "C" */
     2899# endif
     2900mrb_int mrb_jmpbuf::jmpbuf_id = 0;
     2901# if !defined(MRB_ENABLE_CXX_ABI)
     2902extern "C" {
     2903# endif
     2904#endif
Note: See TracChangeset for help on using the changeset viewer.