made mrb_get_args() better (optinal args, type checks); close #173 #176

include/mruby.h

@@ -329,7 +329,7 @@ int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
 mrb_value mrb_funcall_argv(mrb_state*, mrb_value, const char*, int, mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, struct RProc*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, mrb_value);
 mrb_sym mrb_intern(mrb_state*,const char*);
 const char *mrb_sym2name(mrb_state*,mrb_sym);
 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);

include/mruby/hash.h

@@ -31,7 +31,7 @@ mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
 mrb_value mrb_hash_getWithDef(mrb_state *mrb, mrb_value hash, mrb_value vkey, mrb_value def);
 mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
 mrb_value mrb_hash(mrb_state *mrb, mrb_value obj);
-void ruby_setenv(mrb_state *mrb, const char *name, const char *value);
+mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
 
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)((obj).value.p))

src/array.c

@@ -177,10 +177,7 @@ mrb_ary_concat_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value other;
 
-  mrb_get_args(mrb, "o", &other);
-  if (mrb_type(other) != MRB_TT_ARRAY) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "expected Array");
-  }
+  mrb_get_args(mrb, "A", &other);
   mrb_ary_concat(mrb, self, other);
   return self;
 }
@@ -193,11 +190,7 @@ mrb_ary_plus(mrb_state *mrb, mrb_value self)
   mrb_value other;
   mrb_value ary;
 
-  mrb_get_args(mrb, "o", &other);
-  if (mrb_type(other) != MRB_TT_ARRAY) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "expected Array");
-  }
-
+  mrb_get_args(mrb, "A", &other);
   ary = mrb_ary_new_capa(mrb, a1->len + RARRAY_LEN(other));
   a2 = mrb_ary_ptr(ary);
   memcpy(a2->buf, a1->buf, sizeof(mrb_value)*a1->len);

src/class.c

@@ -328,15 +328,67 @@ mrb_define_method_vm(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_value b
   kh_value(h, k) = mrb_proc_ptr(body);
 }
 
+static mrb_value
+check_type(mrb_state *mrb, mrb_value val, enum mrb_vtype t, const char *c, const char *m)
+{
+  mrb_value tmp;
+
+  tmp = mrb_check_convert_type(mrb, val, t, c, m);
+  if (mrb_nil_p(tmp)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "expected %s", c);
+  }
+  return tmp;
+}
+
+static mrb_value
+to_str(mrb_state *mrb, mrb_value val)
+{
+  return check_type(mrb, val, MRB_TT_STRING, "String", "to_str");
+}
+
+static mrb_value
+to_ary(mrb_state *mrb, mrb_value val)
+{
+  return check_type(mrb, val, MRB_TT_ARRAY, "Array", "to_ary");
+}
+
+static mrb_value
+to_hash(mrb_state *mrb, mrb_value val)
+{
+  return check_type(mrb, val, MRB_TT_HASH, "Hash", "to_hash");
+}
+
+/*
+  retrieve arguments from mrb_state.
+
+  mrb_get_args(mrb, format, ...)
+  
+  returns number of arguments parsed.
+
+  fortmat specifiers:
+
+   o: Object [mrb_value]
+   S: String [mrb_value]
+   A: Array [mrb_value]
+   H: Hash [mrb_value]
+   s: String [char*,int]
+   z: String [char*]
+   a: Array [mrb_value*,int]
+   f: Float [mrb_float]
+   i: Integer [mrb_int]
+   &: Block [mrb_value]
+   *: rest argument [mrb_value*,int]
+   |: optional
+ */
 int
 mrb_get_args(mrb_state *mrb, const char *format, ...)
 {
   char c;
-  int i=0;
+  int i = 0;
   mrb_value *sp = mrb->stack + 1;
   va_list ap;
   int argc = mrb->ci->argc;
-  int *argcp;
+  int opt = 0;
 
   va_start(ap, format);
   if (argc < 0) {
@@ -346,39 +398,92 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     sp = a->buf;
   }
   while ((c = *format++)) {
+    if (argc < i) {
+      if (opt) continue;
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+    }
     switch (c) {
     case 'o':
       {
         mrb_value *p;
+
         p = va_arg(ap, mrb_value*);
         *p =  *sp;
         i++; sp++;
       }
       break;
-    case 'i':
+    case 'S':
       {
-        mrb_int *p;
+        mrb_value *p;
 
-        p = va_arg(ap, mrb_int*);
-        switch (sp->tt) {
-        case MRB_TT_FIXNUM:
-          *p = mrb_fixnum(*sp);
-          break;
-        case MRB_TT_FLOAT:
-          *p = (mrb_int)mrb_float(*sp);
-          break;
-        case MRB_TT_FALSE:
-          *p = 0;
-          break;
-        default:
-	  {
-	    mrb_value tmp;
+        p = va_arg(ap, mrb_value*);
+	*p = to_str(mrb, *sp);
+        i++; sp++;
+      }
+      break;
+    case 'A':
+      {
+        mrb_value *p;
 
-	    tmp = mrb_convert_type(mrb, *sp, MRB_TT_FIXNUM, "Integer", "to_int");
-	    *p = mrb_fixnum(tmp);
-	  }
-          break;
-        }
+        p = va_arg(ap, mrb_value*);
+	*p = to_ary(mrb, *sp);
+        i++; sp++;
+      }
+      break;
+    case 'H':
+      {
+        mrb_value *p;
+
+        p = va_arg(ap, mrb_value*);
+	*p = to_hash(mrb, *sp);
+        i++; sp++;
+      }
+      break;
+    case 's':
+      {
+	mrb_value ss;
+        struct RString *s;
+        char **ps = 0;
+        int *pl = 0;
+
+	ss = to_str(mrb, *sp);
+	s = mrb_str_ptr(ss);
+	ps = va_arg(ap, char**);
+	*ps = s->buf;
+	pl = va_arg(ap, int*);
+	*pl = s->len;
+        i++; sp++;
+      }
+      break;
+    case 'z':
+      {
+	mrb_value ss;
+        struct RString *s;
+        char **ps;
+
+	ss = to_str(mrb, *sp);
+	s = mrb_str_ptr(ss);
+	if (strlen(s->buf) != s->len) {
+	  mrb_raise(mrb, E_ARGUMENT_ERROR, "String contains NUL");
+	}
+	ps = va_arg(ap, char**);
+	*ps = s->buf;
+        i++; sp++;
+      }
+      break;
+    case 'a':
+      {
+	mrb_value aa;
+        struct RArray *a;
+        mrb_value **pb;
+        int *pl;
+
+	aa = to_ary(mrb, *sp);
+	a = mrb_ary_ptr(aa);
+	pb = va_arg(ap, mrb_value**);
+	*pb = a->buf;
+	pl = va_arg(ap, int*);
+	*pl = a->len;
         i++; sp++;
       }
       break;
@@ -409,53 +514,34 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         i++; sp++;
       }
       break;
-    case 's':
+    case 'i':
       {
-        char **ps = 0;
-        size_t *pl = 0;
-        struct RString *s;
+        mrb_int *p;
 
-        if (argc > i) {
-          s = mrb_str_ptr(*sp);
-          ps = va_arg(ap, char**);
-          *ps = s->buf;
-          pl = va_arg(ap, size_t*);
-          *pl = s->len;
+        p = va_arg(ap, mrb_int*);
+        switch (sp->tt) {
+        case MRB_TT_FIXNUM:
+          *p = mrb_fixnum(*sp);
+          break;
+        case MRB_TT_FLOAT:
+          *p = (mrb_int)mrb_float(*sp);
+          break;
+        case MRB_TT_FALSE:
+          *p = 0;
+          break;
+        default:
+	  {
+	    mrb_value tmp;
+
+	    tmp = mrb_convert_type(mrb, *sp, MRB_TT_FIXNUM, "Integer", "to_int");
+	    *p = mrb_fixnum(tmp);
+	  }
+          break;
         }
         i++; sp++;
       }
       break;
-    case 'a':
-      {
-        mrb_value *var;
-        var = va_arg(ap, mrb_value*);
-        if (argc > i) {
-          if (var) {
-            memcpy(var, sp, sizeof(mrb_value)*(argc-i));
-          }
-          //i = mrb->argc;
-        }
-        else {
-          if (var) *var = mrb_ary_new(mrb);
-        }
-        argcp = va_arg(ap, int*);
-        *argcp = argc-i;
-        goto last_var;
-      }
-      break;
-    case 'b':
-      {
-        struct RProc **p;
-        mrb_value *bp = mrb->stack + 1;
 
-        p = va_arg(ap, struct RProc**);
-        if (mrb->ci->argc > 0) {
-          bp += mrb->ci->argc;
-        }
-        if (mrb_nil_p(*bp)) *p = 0;
-        else *p = mrb_proc_ptr(*bp);
-      }
-      break;
     case '&':
       {
         mrb_value *p, *bp = mrb->stack + 1;
@@ -467,30 +553,34 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         *p = *bp;
       }
       break;
+    case '|':
+      opt = 1;
+      break;
     case '*':
       {
         mrb_value **var;
+	int *pl;
+
         var = va_arg(ap, mrb_value**);
-        argcp = va_arg(ap, int*);
+        pl = va_arg(ap, int*);
         if (argc > i) {
-          *argcp = argc-i;
-          if (*argcp > 0) {
-            if (var) {
-              *var = sp;
-            }
-            i += *argcp;
+          *pl = argc-i;
+          if (*pl > 0) {
+	    *var = sp;
+            i = argc;
           }
         }
         else {
-          *argcp = 0;
+          *pl = 0;
           *var = NULL;
         }
-        goto last_var;
       }
       break;
     }
   }
-last_var:
+  if (!*format && argc > i) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+  }
   va_end(ap);
   return 0;
 }
@@ -679,17 +769,17 @@ mrb_value
 mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass)
 {
   mrb_value *argv;
-  struct RProc *b;
+  mrb_value blk;
   struct RClass *k = mrb_class_ptr(klass);
   struct RClass *c;
   int argc;
   mrb_value obj;
 
-  mrb_get_args(mrb, "b*", &b, &argv, &argc);
+  mrb_get_args(mrb, "*&", &argv, &argc, &blk);
   c = (struct RClass*)mrb_obj_alloc(mrb, k->tt, k);
   c->super = k;
   obj = mrb_obj_value(c);
-  mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, b);
+  mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, blk);
 
   return obj;
 }
@@ -698,18 +788,17 @@ mrb_value
 mrb_instance_new(mrb_state *mrb, mrb_value cv)
 {
   struct RClass *c = mrb_class_ptr(cv);
-  struct RProc *b;
   struct RObject *o;
   enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
-  mrb_value obj;
+  mrb_value obj, blk;
   mrb_value *argv;
   int argc;
 
   if (ttype == 0) ttype = MRB_TT_OBJECT;
   o = (struct RObject*)mrb_obj_alloc(mrb, ttype, c);
   obj = mrb_obj_value(o);
-  mrb_get_args(mrb, "b*", &b, &argv, &argc);
-  mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, b);
+  mrb_get_args(mrb, "*&", &argv, &argc, &blk);
+  mrb_funcall_with_block(mrb, obj, "initialize", argc, argv, blk);
 
   return obj;
 }

src/encoding.c

@@ -1028,8 +1028,8 @@ static mrb_value
 enc_find(mrb_state *mrb, mrb_value klass)
 {
   mrb_value enc;
-  mrb_get_args(mrb, "o", &enc);
 
+  mrb_get_args(mrb, "o", &enc);
   return mrb_enc_from_encoding(mrb, to_encoding(mrb, enc));
 }
 
@@ -1058,6 +1058,7 @@ enc_compatible_p(mrb_state *mrb, mrb_value klass)
     mrb_value str1;
     mrb_value str2;
     mrb_encoding *enc;
+
     mrb_get_args(mrb, "oo", &str1, &str2);
     if (!enc_capable(str1)) return mrb_nil_value();
     if (!enc_capable(str2)) return mrb_nil_value();
@@ -1081,6 +1082,7 @@ static mrb_value
 enc_load(mrb_state *mrb, mrb_value klass)
 {
     mrb_value str;
+
     mrb_get_args(mrb, "o", &str);
     return enc_find(mrb, str);
 }
@@ -1277,6 +1279,7 @@ static mrb_value
 set_default_external(mrb_state *mrb, mrb_value klass)
 {
   mrb_value encoding;
+
   mrb_get_args(mrb, "o", &encoding);
   mrb_warning("setting Encoding.default_external");
   mrb_enc_set_default_external(mrb, encoding);
@@ -1335,6 +1338,7 @@ static mrb_value
 set_default_internal(mrb_state *mrb, mrb_value klass)
 {
   mrb_value encoding;
+
   mrb_get_args(mrb, "o", &encoding);
   mrb_warning("setting Encoding.default_internal");
   mrb_enc_set_default_internal(mrb, encoding);

src/error.c

@@ -83,7 +83,6 @@ exc_exception(mrb_state *mrb, mrb_value self)
   int argc;
 
   mrb_get_args(mrb, "*", &argv, &argc);
-
   if (argc == 0) return self;
   if (argc == 1 && mrb_obj_equal(mrb, self, argv[0])) return self;
   exc = mrb_obj_clone(mrb, self);
@@ -161,7 +160,6 @@ exc_equal(mrb_state *mrb, mrb_value exc)
   mrb_sym id_mesg = mrb_intern(mrb, "mesg");
 
   mrb_get_args(mrb, "o", &obj);
-
   if (mrb_obj_equal(mrb, exc, obj)) return mrb_true_value();
 
   if (mrb_obj_class(mrb, exc) != mrb_obj_class(mrb, obj)) {

src/etc.c

@@ -67,6 +67,7 @@ mrb_lastline_get(mrb_state *mrb)
   //return mrb_nil_value();
   mrb_value *argv;
   int argc;
+
   mrb_get_args(mrb, "*", &argv, &argc);
   if (argc < 1) {
     return mrb_nil_value();

src/gc.c

@@ -844,9 +844,10 @@ gc_interval_ratio_get(mrb_state *mrb, mrb_value obj)
 static mrb_value
 gc_interval_ratio_set(mrb_state *mrb, mrb_value obj)
 {
-  mrb_value ratio;
-  mrb_get_args(mrb, "o", &ratio);
-  mrb->gc_interval_ratio = mrb_fixnum(mrb_to_int(mrb, ratio));
+  mrb_int ratio;
+
+  mrb_get_args(mrb, "i", &ratio);
+  mrb->gc_interval_ratio = ratio;
   return mrb_nil_value();
 }
 
@@ -876,9 +877,10 @@ gc_step_ratio_get(mrb_state *mrb, mrb_value obj)
 static mrb_value
 gc_step_ratio_set(mrb_state *mrb, mrb_value obj)
 {
-  mrb_value ratio;
-  mrb_get_args(mrb, "o", &ratio);
-  mrb->gc_step_ratio = mrb_fixnum(mrb_to_int(mrb, ratio));
+  mrb_int ratio;
+
+  mrb_get_args(mrb, "i", &ratio);
+  mrb->gc_step_ratio = ratio;
   return mrb_nil_value();
 }
 

src/hash.c

@@ -283,7 +283,6 @@ mrb_hash_init_core(mrb_state *mrb, mrb_value hash)
   int argc;
 
   mrb_get_args(mrb, "o*", &block, &argv, &argc);
-
   mrb_hash_modify(mrb, hash);
   if (mrb_nil_p(block)) {
     if (argc > 0) {
@@ -434,7 +433,6 @@ mrb_hash_default(mrb_state *mrb, mrb_value hash)
   mrb_value key;
 
   mrb_get_args(mrb, "*", &argv, &argc);
-
   if (MRB_RHASH_PROCDEFAULT_P(hash)) {
     if (argc == 0) return mrb_nil_value();
     key = argv[0];
@@ -470,8 +468,8 @@ static mrb_value
 mrb_hash_set_default(mrb_state *mrb, mrb_value hash)
 {
   mrb_value ifnone;
-  mrb_get_args(mrb, "o", &ifnone);
 
+  mrb_get_args(mrb, "o", &ifnone);
   mrb_hash_modify(mrb, hash);
   mrb_iv_set(mrb, hash, mrb_intern(mrb, "ifnone"), ifnone);
   RHASH(hash)->flags &= ~(MRB_HASH_PROC_DEFAULT);
@@ -521,8 +519,8 @@ static mrb_value
 mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
 {
   mrb_value ifnone;
-  mrb_get_args(mrb, "o", &ifnone);
 
+  mrb_get_args(mrb, "o", &ifnone);
   mrb_hash_modify(mrb, hash);
   mrb_iv_set(mrb, hash, mrb_intern(mrb, "ifnone"), ifnone);
   RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
@@ -789,7 +787,6 @@ mrb_hash_replace(mrb_state *mrb, mrb_value hash)
   khiter_t k;
 
   mrb_get_args(mrb, "o", &hash2);
-
   mrb_hash_modify_check(mrb, hash);
   hash2 = to_hash(mrb, hash2);
   if (mrb_obj_equal(mrb, hash, hash2)) return hash;
@@ -1207,6 +1204,7 @@ static mrb_value
 mrb_hash_equal(mrb_state *mrb, mrb_value hash1)
 {
   mrb_value hash2;
+
   mrb_get_args(mrb, "o", &hash2);
   return hash_equal(mrb, hash1, hash2, FALSE);
 }
@@ -1224,6 +1222,7 @@ static mrb_value
 mrb_hash_eql(mrb_state *mrb, mrb_value hash1)
 {
   mrb_value hash2;
+
   mrb_get_args(mrb, "o", &hash2);
   return hash_equal(mrb, hash1, hash2, TRUE);
 }
@@ -1292,7 +1291,6 @@ mrb_hash_assoc(mrb_state *mrb, mrb_value hash)
   mrb_value key, value, has_key;
 
   mrb_get_args(mrb, "o", &key);
-
   if (mrb_nil_p(key))
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
 
@@ -1325,7 +1323,6 @@ mrb_hash_rassoc(mrb_state *mrb, mrb_value hash)
   mrb_value key, value, has_key;
 
   mrb_get_args(mrb, "o", &key);
-
   if (mrb_nil_p(key))
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
 

src/kernel.c

@@ -958,10 +958,10 @@ class_instance_method_list(mrb_state *mrb, int argc, mrb_value *argv, struct RCl
   }
   else {
       mrb_value r;
+
       mrb_get_args(mrb, "o", &r);
       recur = mrb_test(r);
   }
-
   ary = mrb_ary_new(mrb);
   oldklass = 0;
   while (klass && (klass != oldklass)) {

src/numeric.c

@@ -306,6 +306,7 @@ static mrb_value
 num_eql(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
+  
   mrb_get_args(mrb, "o", &y);
   if (mrb_type(x) != mrb_type(y)) return mrb_false_value();
   if (mrb_equal(mrb, x, y)) {
@@ -942,8 +943,8 @@ fix_xor(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
   mrb_int val;
-  mrb_get_args(mrb, "o", &y);
 
+  mrb_get_args(mrb, "o", &y);
   y = bit_coerce(mrb, y);
   val = mrb_fixnum(x) ^ mrb_fixnum(y);
   return mrb_fixnum_value(val);
@@ -965,8 +966,8 @@ mrb_fix_lshift(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
   mrb_int val, width;
-  mrb_get_args(mrb, "o", &y);
 
+  mrb_get_args(mrb, "o", &y);
   val = mrb_fixnum(x);
   y = bit_coerce(mrb, y);
   width = mrb_fixnum(y);
@@ -1000,8 +1001,8 @@ mrb_fix_rshift(mrb_state *mrb, mrb_value x)
 {
   mrb_value y;
   mrb_int i, val;
-  mrb_get_args(mrb, "o", &y);
 
+  mrb_get_args(mrb, "o", &y);
   val = mrb_fixnum(x);
   y = bit_coerce(mrb, y);
   i = mrb_fixnum(y);

src/range.c

@@ -433,8 +433,8 @@ static mrb_value
 range_eql(mrb_state *mrb, mrb_value range)
 {
   mrb_value obj;
-  mrb_get_args(mrb, "o", &obj);
 
+  mrb_get_args(mrb, "o", &obj);
   if (mrb_obj_equal(mrb, range, obj))
     return mrb_true_value();
   if (!mrb_obj_is_kind_of(mrb, obj, RANGE_CLASS))
@@ -447,16 +447,17 @@ mrb_value
 range_initialize_copy(mrb_state *mrb, mrb_value copy)
 {
   mrb_value src;
+
   mrb_get_args(mrb, "o", &src);
 
-    if (mrb_obj_equal(mrb, copy, src)) return copy;
-    //mrb_check_frozen(copy);
-    if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
-      mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
-    }
-    memcpy(mrb_range_ptr(copy), mrb_range_ptr(src), sizeof(struct RRange));
+  if (mrb_obj_equal(mrb, copy, src)) return copy;
+  //mrb_check_frozen(copy);
+  if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
+    mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
+  }
+  memcpy(mrb_range_ptr(copy), mrb_range_ptr(src), sizeof(struct RRange));
 
-    return copy;
+  return copy;
 }
 
 void

src/re.c

@@ -229,6 +229,7 @@ static mrb_value
 mrb_reg_s_quote(mrb_state *mrb, mrb_value c/*, mrb_value str*/)
 {
     mrb_value str;
+
     mrb_get_args(mrb, "o", &str);
     return mrb_reg_quote(mrb, reg_operand(mrb, str, 1/*TRUE*/));
 }
@@ -1520,6 +1521,7 @@ mrb_value
 mrb_reg_match(mrb_state *mrb, mrb_value re/*, mrb_value str*/)
 {
   mrb_value str;
+
   mrb_get_args(mrb, "o", &str);
   return mrb_reg_match_str(mrb, re, str);
 }
@@ -1582,7 +1584,7 @@ mrb_reg_match_m(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value re)
   long pos;
 
   //if (mrb_scan_args(argc, argv, "11", &str, &initpos) == 2) {
-  mrb_get_args(mrb, "&*", &b, &argv, &argc);
+  mrb_get_args(mrb, "*&", &argv, &argc, &b);
   if (argc == 2) {
     initpos = argv[1];
     pos = mrb_fixnum(initpos);

src/string.c

@@ -1101,6 +1101,7 @@ static mrb_value
 mrb_str_match(mrb_state *mrb, mrb_value self/* x */)
 {
   mrb_value y;
+
   mrb_get_args(mrb, "o", &y);
   switch (mrb_type(y)) {
     case MRB_TT_STRING:
@@ -2048,7 +2049,7 @@ mrb_str_each_line(mrb_state *mrb, mrb_value str)
   int argc;
 
   //if (mrb_scan_args(argc, argv, "01", &rs) == 0) {
-  mrb_get_args(mrb, "&*", &b, &argv, &argc);
+  mrb_get_args(mrb, "*&", &argv, &argc, &b);
   if (argc > 0) {
     rs = argv[0];
   } else {
@@ -2632,8 +2633,8 @@ mrb_str_include(mrb_state *mrb, mrb_value self)
 {
   mrb_int i;
   mrb_value str2;
-  mrb_get_args(mrb, "o", &str2);
 
+  mrb_get_args(mrb, "o", &str2);
   if (mrb_type(str2) == MRB_TT_FIXNUM) {
     if (memchr(RSTRING_PTR(self), mrb_fixnum(str2), RSTRING_LEN(self)))
       return mrb_true_value();
@@ -2955,7 +2956,8 @@ mrb_str_match_m(mrb_state *mrb, mrb_value self)
   mrb_value *argv;
   int argc;
   mrb_value re, result, b;
-  mrb_get_args(mrb, "&*", &b, &argv, &argc);
+
+  mrb_get_args(mrb, "*&", &argv, &argc, &b);
   if (argc < 1)
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%d for 1..2)", argc);
   re = argv[0];
@@ -3336,7 +3338,7 @@ mrb_str_scan(mrb_state *mrb, mrb_value str)
   char *p = ps->buf;
   long len = ps->len;
 
-  mrb_get_args(mrb, "&o", &b, &pat);
+  mrb_get_args(mrb, "o&", &pat, &b);
   pat = get_pat(mrb, pat, 1);
   if (!mrb_block_given_p()) {
     mrb_value ary = mrb_ary_new(mrb);
@@ -4292,6 +4294,7 @@ static mrb_value
 mrb_str_force_encoding(mrb_state *mrb, mrb_value self)
 {
   mrb_value enc;
+
   mrb_get_args(mrb, "o", &enc);
   str_modifiable(self);
   mrb_enc_associate(mrb, self, mrb_to_encoding(mrb, enc));

src/struct.c

@@ -533,19 +533,20 @@ mrb_value
 mrb_struct_init_copy(mrb_state *mrb, mrb_value copy)
 {
   mrb_value s;
+
   mrb_get_args(mrb, "o", &s);
 
-    if (mrb_obj_equal(mrb, copy, s)) return copy;
-    //mrb_check_frozen(copy);
-    if (!mrb_obj_is_instance_of(mrb, s, mrb_obj_class(mrb, copy))) {
-      mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
-    }
-    if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
-      mrb_raise(mrb, E_TYPE_ERROR, "struct size mismatch");
-    }
-    memcpy(RSTRUCT_PTR(copy), RSTRUCT_PTR(s), sizeof(mrb_value)*RSTRUCT_LEN(copy));
+  if (mrb_obj_equal(mrb, copy, s)) return copy;
+  //mrb_check_frozen(copy);
+  if (!mrb_obj_is_instance_of(mrb, s, mrb_obj_class(mrb, copy))) {
+    mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
+  }
+  if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "struct size mismatch");
+  }
+  memcpy(RSTRUCT_PTR(copy), RSTRUCT_PTR(s), sizeof(mrb_value)*RSTRUCT_LEN(copy));
 
-    return copy;
+  return copy;
 }
 
 static mrb_value
@@ -668,24 +669,25 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s)
   long i;
   mrb_value idx;
   mrb_value val;
+
   mrb_get_args(mrb, "oo", &idx, &val);
 
-    if (mrb_type(idx) == MRB_TT_STRING || mrb_type(idx) == MRB_TT_SYMBOL) {
-      return mrb_struct_aset_id(mrb, s, mrb_to_id(mrb, idx), val);
-    }
+  if (mrb_type(idx) == MRB_TT_STRING || mrb_type(idx) == MRB_TT_SYMBOL) {
+    return mrb_struct_aset_id(mrb, s, mrb_to_id(mrb, idx), val);
+  }
 
-    i = mrb_fixnum(idx);
-    if (i < 0) i = RSTRUCT_LEN(s) + i;
-    if (i < 0) {
-        mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)",
-             i, RSTRUCT_LEN(s));
-    }
-    if (RSTRUCT_LEN(s) <= i) {
-        mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)",
-             i, RSTRUCT_LEN(s));
-    }
-    mrb_struct_modify(s);
-    return RSTRUCT_PTR(s)[i] = val;
+  i = mrb_fixnum(idx);
+  if (i < 0) i = RSTRUCT_LEN(s) + i;
+  if (i < 0) {
+    mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too small for struct(size:%ld)",
+	      i, RSTRUCT_LEN(s));
+  }
+  if (RSTRUCT_LEN(s) <= i) {
+    mrb_raise(mrb, E_INDEX_ERROR, "offset %ld too large for struct(size:%ld)",
+	      i, RSTRUCT_LEN(s));
+  }
+  mrb_struct_modify(s);
+  return RSTRUCT_PTR(s)[i] = val;
 }
 
 static mrb_value

src/time.c

@@ -268,7 +268,7 @@ mrb_time_gm(mrb_state *mrb, mrb_value self)
 { 
   mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0, amin = 0, asec = 0, ausec = 0;
 
-  mrb_get_args(mrb, "iiiiiii",
+  mrb_get_args(mrb, "i|iiiiii",
                 &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
   return mrb_time_wrap(mrb, mrb_class_ptr(self),
 		       time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_UTC));
@@ -282,7 +282,7 @@ mrb_time_local(mrb_state *mrb, mrb_value self)
 { 
   mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0, amin = 0, asec = 0, ausec = 0;
 
-  mrb_get_args(mrb, "iiiiiii",
+  mrb_get_args(mrb, "i|iiiiii",
                 &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
   return mrb_time_wrap(mrb, mrb_class_ptr(self),
 		       time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_LOCAL));
@@ -352,7 +352,6 @@ mrb_time_minus(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
 
   mrb_get_args(mrb, "f", &f);
-  
   tm = mrb_get_datatype(mrb, self, &mrb_time_type);
   if(!tm) return mrb_nil_value();
   f -= tm->sec;
@@ -499,8 +498,8 @@ static mrb_value
 mrb_time_initialize_copy(mrb_state *mrb, mrb_value copy)
 {
   mrb_value src;
-  mrb_get_args(mrb, "o", &src);
 
+  mrb_get_args(mrb, "o", &src);
   if (mrb_obj_equal(mrb, copy, src)) return copy;
   if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
     mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");

src/vm.c

@@ -160,7 +160,7 @@ ecall(mrb_state *mrb, int i)
 }
 
 mrb_value
-mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv, struct RProc *blk)
+mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv, mrb_value blk)
 {
   struct RProc *p;
   struct RClass *c;
@@ -197,12 +197,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int arg
   else if (argc > 0) {
     memcpy(mrb->stack+1, argv, sizeof(mrb_value)*argc);
   }
-  if (!blk) {
-    mrb->stack[argc+1] = mrb_nil_value();
-  }
-  else {
-    mrb->stack[argc+1] = mrb_obj_value(blk);
-  }
+  mrb->stack[argc+1] = blk;
 
   if (MRB_PROC_CFUNC_P(p)) {
     val = p->body.func(mrb, self);
@@ -218,7 +213,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int arg
 mrb_value
 mrb_funcall_argv(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv)
 {
-  return mrb_funcall_with_block(mrb, self, name, argc, argv, 0);
+  return mrb_funcall_with_block(mrb, self, name, argc, argv, mrb_nil_value());
 }
 
 mrb_value