script_core 0.2.6 → 0.2.7

data/ext/enterprise_script_service/mruby/src/error.c

@@ -160,9 +160,8 @@ set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace)
 static mrb_value
 exc_set_backtrace(mrb_state *mrb, mrb_value exc)
 {
-  mrb_value backtrace;
+  mrb_value backtrace = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &backtrace);
   set_backtrace(mrb, exc, backtrace);
   return backtrace;
 }

data/ext/enterprise_script_service/mruby/src/etc.c

@@ -132,7 +132,6 @@ mrb_obj_id(mrb_value obj)
   case MRB_TT_HASH:
   case MRB_TT_RANGE:
   case MRB_TT_EXCEPTION:
-  case MRB_TT_FILE:
   case MRB_TT_DATA:
   case MRB_TT_ISTRUCT:
   default:

data/ext/enterprise_script_service/mruby/src/gc.c

@@ -716,10 +716,10 @@ gc_mark_children(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
       struct REnv *e = (struct REnv*)obj;
       mrb_int i, len;
 
-      if (MRB_ENV_STACK_SHARED_P(e) && e->cxt && e->cxt->fib) {
+      if (MRB_ENV_ONSTACK_P(e) && e->cxt && e->cxt->fib) {
         mrb_gc_mark(mrb, (struct RBasic*)e->cxt->fib);
       }
-      len = MRB_ENV_STACK_LEN(e);
+      len = MRB_ENV_LEN(e);
       for (i=0; i<len; i++) {
         mrb_gc_mark_value(mrb, e->stack[i]);
       }
@@ -820,7 +820,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
     {
       struct REnv *e = (struct REnv*)obj;
 
-      if (MRB_ENV_STACK_SHARED_P(e)) {
+      if (MRB_ENV_ONSTACK_P(e)) {
         /* cannot be freed */
         e->stack = NULL;
         break;
@@ -842,7 +842,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
           while (ce <= ci) {
             struct REnv *e = ci->env;
             if (e && !mrb_object_dead_p(mrb, (struct RBasic*)e) &&
-                e->tt == MRB_TT_ENV && MRB_ENV_STACK_SHARED_P(e)) {
+                e->tt == MRB_TT_ENV && MRB_ENV_ONSTACK_P(e)) {
               mrb_env_unshare(mrb, e);
             }
             ci--;
@@ -990,7 +990,7 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
     break;
 
   case MRB_TT_ENV:
-    children += MRB_ENV_STACK_LEN(obj);
+    children += MRB_ENV_LEN(obj);
     break;
 
   case MRB_TT_FIBER:

data/ext/enterprise_script_service/mruby/src/hash.c

@@ -73,7 +73,7 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key)
 
   default:
     hv = mrb_funcall(mrb, key, "hash", 0);
-    h = (size_t)t ^ (size_t)mrb_fixnum(hv);
+    h = (size_t)tt ^ (size_t)mrb_fixnum(hv);
     break;
   }
   if (index && (index != t->index || capa != index->capa)) {
@@ -641,12 +641,11 @@ static mrb_value hash_default(mrb_state *mrb, mrb_value hash, mrb_value key);
 static mrb_value
 mrb_hash_init_copy(mrb_state *mrb, mrb_value self)
 {
-  mrb_value orig;
+  mrb_value orig = mrb_get_arg1(mrb);
   struct RHash* copy;
   htable *orig_h;
   mrb_value ifnone, vret;
 
-  mrb_get_args(mrb, "o", &orig);
   if (mrb_obj_equal(mrb, self, orig)) return self;
   if ((mrb_type(self) != mrb_type(orig)) || (mrb_obj_class(mrb, self) != mrb_obj_class(mrb, orig))) {
       mrb_raise(mrb, E_TYPE_ERROR, "initialize_copy should take same class object");
@@ -828,9 +827,8 @@ mrb_hash_init(mrb_state *mrb, mrb_value hash)
 static mrb_value
 mrb_hash_aget(mrb_state *mrb, mrb_value self)
 {
-  mrb_value key;
+  mrb_value key = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &key);
   return mrb_hash_get(mrb, self, key);
 }
 
@@ -913,9 +911,8 @@ mrb_hash_default(mrb_state *mrb, mrb_value hash)
 static mrb_value
 mrb_hash_set_default(mrb_state *mrb, mrb_value hash)
 {
-  mrb_value ifnone;
+  mrb_value ifnone = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &ifnone);
   mrb_hash_modify(mrb, hash);
   mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
   RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
@@ -969,9 +966,8 @@ mrb_hash_default_proc(mrb_state *mrb, mrb_value hash)
 static mrb_value
 mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
 {
-  mrb_value ifnone;
+  mrb_value ifnone = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &ifnone);
   mrb_hash_modify(mrb, hash);
   mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
   if (!mrb_nil_p(ifnone)) {
@@ -1003,9 +999,8 @@ mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
 static mrb_value
 mrb_hash_delete(mrb_state *mrb, mrb_value self)
 {
-  mrb_value key;
+  mrb_value key = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &key);
   mrb_hash_modify(mrb, self);
   return mrb_hash_delete_key(mrb, self, key);
 }
@@ -1288,10 +1283,9 @@ mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key)
 static mrb_value
 mrb_hash_has_key(mrb_state *mrb, mrb_value hash)
 {
-  mrb_value key;
+  mrb_value key = mrb_get_arg1(mrb);
   mrb_bool key_p;
 
-  mrb_get_args(mrb, "o", &key);
   key_p = mrb_hash_key_p(mrb, hash, key);
   return mrb_bool_value(key_p);
 }
@@ -1331,10 +1325,9 @@ hash_has_value_i(mrb_state *mrb, mrb_value key, mrb_value val, void *p)
 static mrb_value
 mrb_hash_has_value(mrb_state *mrb, mrb_value hash)
 {
-  mrb_value val;
+  mrb_value val = mrb_get_arg1(mrb);
   struct has_v_arg arg;
   
-  mrb_get_args(mrb, "o", &val);
   arg.found = FALSE;
   arg.val = val;
   ht_foreach(mrb, RHASH_TBL(hash), hash_has_value_i, &arg);

data/ext/enterprise_script_service/mruby/src/kernel.c

@@ -71,9 +71,8 @@ mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_equal_m(mrb_state *mrb, mrb_value self)
 {
-  mrb_value arg;
+  mrb_value arg = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &arg);
   return mrb_bool_value(mrb_equal(mrb, self, arg));
 }
 
@@ -161,7 +160,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
     /* use saved block arg position */
     bidx = MRB_ENV_BIDX(e);
     /* bidx may be useless (e.g. define_method) */
-    if (bidx >= MRB_ENV_STACK_LEN(e))
+    if (bidx >= MRB_ENV_LEN(e))
       return mrb_false_value();
     bp = &e->stack[bidx];
   }
@@ -471,9 +470,8 @@ mrb_obj_hash(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
 {
-  mrb_value orig;
+  mrb_value orig = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &orig);
   if (mrb_obj_equal(mrb, self, orig)) return self;
   if ((mrb_type(self) != mrb_type(orig)) || (mrb_obj_class(mrb, self) != mrb_obj_class(mrb, orig))) {
       mrb_raise(mrb, E_TYPE_ERROR, "initialize_copy should take same class object");
@@ -744,12 +742,11 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_obj_ceqq(mrb_state *mrb, mrb_value self)
 {
-  mrb_value v;
+  mrb_value v = mrb_get_arg1(mrb);
   mrb_int i, len;
   mrb_sym eqq = mrb_intern_lit(mrb, "===");
   mrb_value ary = mrb_ary_splat(mrb, self);
 
-  mrb_get_args(mrb, "o", &v);
   len = RARRAY_LEN(ary);
   for (i=0; i<len; i++) {
     mrb_value c = mrb_funcall_argv(mrb, mrb_ary_entry(ary, i), eqq, 1, &v);

data/ext/enterprise_script_service/mruby/src/numeric.c

@@ -67,12 +67,11 @@ mrb_int_value(mrb_state *mrb, mrb_float f)
 static mrb_value
 integral_pow(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 #ifndef MRB_WITHOUT_FLOAT
   mrb_float d;
 #endif
 
-  mrb_get_args(mrb, "o", &y);
   if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) {
     /* try ipow() */
     mrb_int base = mrb_fixnum(x);
@@ -116,9 +115,8 @@ static mrb_value
 integral_idiv(mrb_state *mrb, mrb_value x)
 {
 #ifdef MRB_WITHOUT_FLOAT
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   if (!mrb_fixnum_p(y)) {
     mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
   }
@@ -154,9 +152,8 @@ static mrb_value
 integral_div(mrb_state *mrb, mrb_value x)
 {
 #ifdef MRB_WITHOUT_FLOAT
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   if (!mrb_fixnum_p(y)) {
     mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
   }
@@ -271,9 +268,8 @@ flo_to_s(mrb_state *mrb, mrb_value flt)
 static mrb_value
 flo_minus(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y));
 }
 
@@ -289,9 +285,8 @@ flo_minus(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_mul(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y));
 }
 
@@ -351,11 +346,9 @@ flodivmod(mrb_state *mrb, double x, double y, mrb_float *divp, mrb_float *modp)
 static mrb_value
 flo_mod(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
   mrb_float mod;
 
-  mrb_get_args(mrb, "o", &y);
-
   flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), 0, &mod);
   return mrb_float_value(mrb, mod);
 }
@@ -376,9 +369,8 @@ flo_mod(mrb_state *mrb, mrb_value x)
 static mrb_value
 fix_eql(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   if (!mrb_fixnum_p(y)) return mrb_false_value();
   return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
 }
@@ -387,9 +379,8 @@ fix_eql(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_eql(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   if (!mrb_float_p(y)) return mrb_false_value();
   return mrb_bool_value(mrb_float(x) == mrb_float(y));
 }
@@ -410,8 +401,7 @@ flo_eql(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_eq(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
-  mrb_get_args(mrb, "o", &y);
+  mrb_value y = mrb_get_arg1(mrb);
 
   switch (mrb_type(y)) {
   case MRB_TT_FIXNUM:
@@ -429,7 +419,6 @@ value_int64(mrb_state *mrb, mrb_value x)
   switch (mrb_type(x)) {
   case MRB_TT_FIXNUM:
     return (int64_t)mrb_fixnum(x);
-    break;
   case MRB_TT_FLOAT:
     return (int64_t)mrb_float(x);
   default:
@@ -460,9 +449,8 @@ flo_rev(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_and(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
   int64_t v1, v2;
-  mrb_get_args(mrb, "o", &y);
 
   v1 = (int64_t)mrb_float(x);
   v2 = value_int64(mrb, y);
@@ -472,9 +460,8 @@ flo_and(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_or(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
   int64_t v1, v2;
-  mrb_get_args(mrb, "o", &y);
 
   v1 = (int64_t)mrb_float(x);
   v2 = value_int64(mrb, y);
@@ -484,9 +471,8 @@ flo_or(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_xor(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
   int64_t v1, v2;
-  mrb_get_args(mrb, "o", &y);
 
   v1 = (int64_t)mrb_float(x);
   v2 = value_int64(mrb, y);
@@ -847,9 +833,8 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 static mrb_value
 fix_mul(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   return fixnum_mul(mrb, x, y);
 }
 
@@ -894,10 +879,9 @@ fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp)
 static mrb_value
 fix_mod(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
   mrb_int a, b;
 
-  mrb_get_args(mrb, "o", &y);
   a = mrb_fixnum(x);
    if (mrb_fixnum_p(y) && a != MRB_INT_MIN && (b=mrb_fixnum(y)) != MRB_INT_MIN) {
     mrb_int mod;
@@ -936,9 +920,7 @@ fix_mod(mrb_state *mrb, mrb_value x)
 static mrb_value
 fix_divmod(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
-
-  mrb_get_args(mrb, "o", &y);
+  mrb_value y = mrb_get_arg1(mrb);
 
   if (mrb_fixnum_p(y)) {
     mrb_int div, mod;
@@ -975,12 +957,10 @@ fix_divmod(mrb_state *mrb, mrb_value x)
 static mrb_value
 flo_divmod(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
   mrb_float div, mod;
   mrb_value a, b;
 
-  mrb_get_args(mrb, "o", &y);
-
   flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod);
   a = mrb_int_value(mrb, div);
   b = mrb_float_value(mrb, mod);
@@ -1003,9 +983,8 @@ flo_divmod(mrb_state *mrb, mrb_value x)
 static mrb_value
 fix_equal(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   switch (mrb_type(y)) {
   case MRB_TT_FIXNUM:
     return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
@@ -1062,9 +1041,8 @@ static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
 static mrb_value
 fix_and(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   bit_op(x, y, and, &);
 }
 
@@ -1079,9 +1057,8 @@ fix_and(mrb_state *mrb, mrb_value x)
 static mrb_value
 fix_or(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   bit_op(x, y, or, |);
 }
 
@@ -1096,9 +1073,8 @@ fix_or(mrb_state *mrb, mrb_value x)
 static mrb_value
 fix_xor(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   bit_op(x, y, or, ^);
 }
 
@@ -1320,9 +1296,8 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 static mrb_value
 fix_plus(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &other);
   return fixnum_plus(mrb, self, other);
 }
 
@@ -1378,9 +1353,8 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 static mrb_value
 fix_minus(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &other);
   return fixnum_minus(mrb, self, other);
 }
 
@@ -1497,10 +1471,9 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
 static mrb_value
 integral_cmp(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
 
-  mrb_get_args(mrb, "o", &other);
   n = cmpnum(mrb, self, other);
   if (n == -2) return mrb_nil_value();
   return mrb_fixnum_value(n);
@@ -1515,10 +1488,9 @@ cmperr(mrb_state *mrb, mrb_value v1, mrb_value v2)
 static mrb_value
 integral_lt(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
 
-  mrb_get_args(mrb, "o", &other);
   n = cmpnum(mrb, self, other);
   if (n == -2) cmperr(mrb, self, other);
   if (n < 0) return mrb_true_value();
@@ -1528,10 +1500,9 @@ integral_lt(mrb_state *mrb, mrb_value self)
 static mrb_value
 integral_le(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
 
-  mrb_get_args(mrb, "o", &other);
   n = cmpnum(mrb, self, other);
   if (n == -2) cmperr(mrb, self, other);
   if (n <= 0) return mrb_true_value();
@@ -1541,10 +1512,9 @@ integral_le(mrb_state *mrb, mrb_value self)
 static mrb_value
 integral_gt(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
 
-  mrb_get_args(mrb, "o", &other);
   n = cmpnum(mrb, self, other);
   if (n == -2) cmperr(mrb, self, other);
   if (n > 0) return mrb_true_value();
@@ -1554,10 +1524,9 @@ integral_gt(mrb_state *mrb, mrb_value self)
 static mrb_value
 integral_ge(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other;
+  mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
 
-  mrb_get_args(mrb, "o", &other);
   n = cmpnum(mrb, self, other);
   if (n == -2) cmperr(mrb, self, other);
   if (n >= 0) return mrb_true_value();
@@ -1609,9 +1578,8 @@ num_infinite_p(mrb_state *mrb, mrb_value self)
 static mrb_value
 flo_plus(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y;
+  mrb_value y = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &y);
   return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y));
 }
 #endif