eliminate plain int except for a few cases like arena_index

include/mruby.h

@@ -194,7 +194,7 @@ void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_fun
 void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
 void mrb_undef_method(mrb_state*, struct RClass*, const char*);
 void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
-mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, int argc, const mrb_value *argv);
+mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv);
 #define mrb_class_new_instance(mrb,argc,argv,c) mrb_obj_new(mrb,c,argc,argv)
 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
@@ -242,7 +242,7 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
 #define ARGS_ANY()          MRB_ARGS_ANY()
 #define ARGS_NONE()         MRB_ARGS_NONE()
 
-int mrb_get_args(mrb_state *mrb, const char *format, ...);
+mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 /* `strlen` for character string literals (use with caution or `strlen` instead)
     Adjacent string literals are concatenated in C/C++ in translation phase 6.
@@ -252,9 +252,9 @@ int mrb_get_args(mrb_state *mrb, const char *format, ...);
 */
 #define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
 
-mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
-mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, const mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, const mrb_value*, mrb_value);
+mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...);
+mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value);
 mrb_sym mrb_intern_cstr(mrb_state*,const char*);
 mrb_sym mrb_intern(mrb_state*,const char*,size_t);
 mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
@@ -376,8 +376,8 @@ void mrb_print_error(mrb_state *mrb);
 #define E_KEY_ERROR                 (mrb_class_get(mrb, "KeyError"))
 
 mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
-mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv);
-mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv, mrb_value self, struct RClass *c);
+mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
+mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c);
 
 void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
@@ -400,7 +400,7 @@ mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
 mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
 
 /* fiber functions (you need to link mruby-fiber mrbgem to use) */
-mrb_value mrb_fiber_yield(mrb_state *mrb, int argc, const mrb_value *argv);
+mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
 #define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError"))
 
 /* memory pool implementation */

include/mruby/string.h

@@ -72,7 +72,7 @@ char *mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr);
 int mrb_str_offset(mrb_state *mrb, mrb_value str, int pos);
 mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
-mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck);
+mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
 double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
 mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
 mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str);

mrbgems/mruby-fiber/src/fiber.c

@@ -126,7 +126,7 @@ fiber_check(mrb_state *mrb, mrb_value fib)
 }
 
 static mrb_value
-fiber_result(mrb_state *mrb, const mrb_value *a, int len)
+fiber_result(mrb_state *mrb, const mrb_value *a, mrb_int len)
 {
   if (len == 0) return mrb_nil_value();
   if (len == 1) return a[0];
@@ -137,7 +137,7 @@ fiber_result(mrb_state *mrb, const mrb_value *a, int len)
 #define MARK_CONTEXT_MODIFY(c) (c)->ci->target_class = NULL
 
 static mrb_value
-fiber_switch(mrb_state *mrb, mrb_value self, int len, const mrb_value *a, mrb_bool resume)
+fiber_switch(mrb_state *mrb, mrb_value self, mrb_int len, const mrb_value *a, mrb_bool resume)
 {
   struct mrb_context *c = fiber_check(mrb, self);
   mrb_callinfo *ci;
@@ -203,7 +203,8 @@ static mrb_value
 fiber_resume(mrb_state *mrb, mrb_value self)
 {
   mrb_value *a;
-  int len;
+  mrb_int len;
+
   mrb_get_args(mrb, "*", &a, &len);
   return fiber_switch(mrb, self, len, a, TRUE);
 }
@@ -251,7 +252,7 @@ fiber_transfer(mrb_state *mrb, mrb_value self)
 {
   struct mrb_context *c = fiber_check(mrb, self);
   mrb_value* a;
-  int len;
+  mrb_int len;
 
   mrb_get_args(mrb, "*", &a, &len);
 
@@ -271,7 +272,7 @@ fiber_transfer(mrb_state *mrb, mrb_value self)
 }
 
 mrb_value
-mrb_fiber_yield(mrb_state *mrb, int len, const mrb_value *a)
+mrb_fiber_yield(mrb_state *mrb, mrb_int len, const mrb_value *a)
 {
   struct mrb_context *c = mrb->c;
   mrb_callinfo *ci;
@@ -307,7 +308,7 @@ static mrb_value
 fiber_yield(mrb_state *mrb, mrb_value self)
 {
   mrb_value *a;
-  int len;
+  mrb_int len;
 
   mrb_get_args(mrb, "*", &a, &len);
   return mrb_fiber_yield(mrb, len, a);

src/array.c

@@ -235,12 +235,11 @@ static mrb_value
 mrb_ary_s_create(mrb_state *mrb, mrb_value self)
 {
   mrb_value *vals;
-  int len;
+  mrb_int len;
 
   mrb_get_args(mrb, "*", &vals, &len);
-  mrb_assert(len <= MRB_INT_MAX); /* A rare case. So choosed assert() not raise(). */
 
-  return mrb_ary_new_from_values(mrb, (mrb_int)len, vals);
+  return mrb_ary_new_from_values(mrb, len, vals);
 }
 
 static void
@@ -409,7 +408,7 @@ static mrb_value
 mrb_ary_push_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value *argv;
-  int len;
+  mrb_int len;
 
   mrb_get_args(mrb, "*", &argv, &len);
   while (len--) {
@@ -495,7 +494,7 @@ mrb_ary_unshift_m(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
   mrb_value *vals;
-  int len;
+  mrb_int len;
 
   mrb_get_args(mrb, "*", &vals, &len);
   if (ARY_SHARED_P(a)
@@ -825,18 +824,10 @@ mrb_ary_last(mrb_state *mrb, mrb_value self)
 {
   struct RArray *a = mrb_ary_ptr(self);
   mrb_int size;
-  mrb_value *vals;
-  int len;
 
-  mrb_get_args(mrb, "*", &vals, &len);
-  if (len > 1) {
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
-  }
+  if (mrb_get_args(mrb, "|i", &size) == 0)
+    return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value();
 
-  if (len == 0) return (a->len > 0)? a->ptr[a->len - 1]: mrb_nil_value();
-
-  /* len == 1 */
-  size = mrb_fixnum(*vals);
   if (size < 0) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "negative array size");
   }

src/class.c

@@ -400,7 +400,7 @@ to_hash(mrb_state *mrb, mrb_value val)
     S:      String         [mrb_value]
     A:      Array          [mrb_value]
     H:      Hash           [mrb_value]
-    s:      String         [char*,int]            Receive two arguments.
+    s:      String         [char*,mrb_int]        Receive two arguments.
     z:      String         [char*]                NUL terminated string.
     a:      Array          [mrb_value*,mrb_int]   Receive two arguments.
     f:      Float          [mrb_float]
@@ -409,11 +409,11 @@ to_hash(mrb_state *mrb, mrb_value val)
     n:      Symbol         [mrb_sym]
     d:      Data           [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified
     &:      Block          [mrb_value]
-    *:      rest argument  [mrb_value*,int]       Receive the rest of the arguments as an array.
+    *:      rest argument  [mrb_value*,mrb_int]   Receive the rest of the arguments as an array.
     |:      optional                              Next argument of '|' and later are optional.
     ?:      optional given [mrb_bool]             true if preceding argument (optional) is given.
  */
-int
+mrb_int
 mrb_get_args(mrb_state *mrb, const char *format, ...)
 {
   char c;
@@ -519,10 +519,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
       {
         mrb_value ss;
         char **ps = 0;
-        int *pl = 0;
+        mrb_int *pl = 0;
 
         ps = va_arg(ap, char**);
-        pl = va_arg(ap, int*);
+        pl = va_arg(ap, mrb_int*);
         if (i < argc) {
           ss = to_str(mrb, *sp++);
           *ps = RSTRING_PTR(ss);
@@ -683,10 +683,10 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     case '*':
       {
         mrb_value **var;
-        int *pl;
+        mrb_int *pl;
 
         var = va_arg(ap, mrb_value**);
-        pl = va_arg(ap, int*);
+        pl = va_arg(ap, mrb_int*);
         if (argc > i) {
           *pl = argc-i;
           if (*pl > 0) {
@@ -788,7 +788,7 @@ static mrb_value
 mrb_mod_include(mrb_state *mrb, mrb_value klass)
 {
   mrb_value *argv;
-  int argc, i;
+  mrb_int argc, i;
 
   mrb_get_args(mrb, "*", &argv, &argc);
   for (i=0; i<argc; i++) {
@@ -1082,7 +1082,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
 {
   mrb_value obj, blk;
   mrb_value *argv;
-  int argc;
+  mrb_int argc;
 
   obj = mrb_instance_alloc(mrb, cv);
   mrb_get_args(mrb, "*&", &argv, &argc, &blk);
@@ -1092,7 +1092,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
 }
 
 mrb_value
-mrb_obj_new(mrb_state *mrb, struct RClass *c, int argc, const mrb_value *argv)
+mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv)
 {
   mrb_value obj;
 
@@ -1183,7 +1183,7 @@ mrb_bob_missing(mrb_state *mrb, mrb_value mod)
 {
   mrb_sym name;
   mrb_value *a;
-  int alen;
+  mrb_int alen;
   mrb_sym inspect;
   mrb_value repr;
 
@@ -1498,7 +1498,7 @@ static mrb_value
 mrb_mod_undef(mrb_state *mrb, mrb_value mod)
 {
   struct RClass *c = mrb_class_ptr(mod);
-  int argc;
+  mrb_int argc;
   mrb_value *argv;
 
   mrb_get_args(mrb, "*", &argv, &argc);
@@ -1790,7 +1790,7 @@ remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
 static mrb_value
 mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
 {
-  int argc;
+  mrb_int argc;
   mrb_value *argv;
 
   mrb_get_args(mrb, "*", &argv, &argc);

src/codegen.c

@@ -2627,7 +2627,7 @@ static void
 codedump(mrb_state *mrb, mrb_irep *irep)
 {
 #ifdef ENABLE_STDIO
-  int i;
+  size_t i;
   int ai;
   mrb_code c;
 
@@ -2635,8 +2635,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
   printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d\n", irep,
          irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen);
 
-  mrb_assert(irep->ilen <= INT_MAX);
-  for (i = 0; i < (int)(irep->ilen); i++) {
+  for (i = 0; i < irep->ilen; i++) {
     ai = mrb_gc_arena_save(mrb);
     printf("%03d ", i);
     c = irep->iseq[i];

src/kernel.c

@@ -392,9 +392,9 @@ mrb_obj_dup(mrb_state *mrb, mrb_value obj)
 }
 
 static mrb_value
-mrb_obj_extend(mrb_state *mrb, int argc, mrb_value *argv, mrb_value obj)
+mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj)
 {
-  int i;
+  mrb_int i;
 
   if (argc == 0) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (at least 1)");
@@ -438,7 +438,7 @@ static mrb_value
 mrb_obj_extend_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value *argv;
-  int argc;
+  mrb_int argc;
 
   mrb_get_args(mrb, "*", &argv, &argc);
   return mrb_obj_extend(mrb, argc, argv, self);
@@ -1014,7 +1014,7 @@ static mrb_value
 obj_respond_to(mrb_state *mrb, mrb_value self)
 {
   mrb_value *argv;
-  int argc;
+  mrb_int argc;
   mrb_value mid, priv;
   mrb_sym id, rtm_id;
   mrb_bool respond_to_p = TRUE;

src/string.c

@@ -1351,8 +1351,7 @@ static mrb_value
 mrb_str_index_m(mrb_state *mrb, mrb_value str)
 {
   mrb_value *argv;
-  int argc;
-
+  mrb_int argc;
   mrb_value sub;
   mrb_int pos;
 
@@ -1695,7 +1694,7 @@ static mrb_value
 mrb_str_rindex_m(mrb_state *mrb, mrb_value str)
 {
   mrb_value *argv;
-  int argc;
+  mrb_int argc;
   mrb_value sub;
   mrb_value vpos;
   mrb_int pos, len = RSTRING_LEN(str);
@@ -2104,7 +2103,7 @@ mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
 }
 
 mrb_value
-mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck)
+mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck)
 {
   char *s;
   mrb_int len;
@@ -2150,16 +2149,9 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, mrb_bool badcheck)
 static mrb_value
 mrb_str_to_i(mrb_state *mrb, mrb_value self)
 {
-  mrb_value *argv;
-  int argc;
-  int base;
-
-  mrb_get_args(mrb, "*", &argv, &argc);
-  if (argc == 0)
-    base = 10;
-  else
-    base = mrb_fixnum(argv[0]);
+  mrb_int base = 10;
 
+  mrb_get_args(mrb, "|i", &base);
   if (base < 0) {
     mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal radix %S", mrb_fixnum_value(base));
   }

src/vm.c

@@ -288,7 +288,7 @@ ecall(mrb_state *mrb, int i)
 #endif
 
 mrb_value
-mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
+mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
 {
   mrb_sym mid = mrb_intern_cstr(mrb, name);
 
@@ -307,7 +307,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
   else {
     mrb_value argv[MRB_FUNCALL_ARGC_MAX];
     va_list ap;
-    int i;
+    mrb_int i;
 
     if (argc > MRB_FUNCALL_ARGC_MAX) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=" TO_STR(MRB_FUNCALL_ARGC_MAX) ")");
@@ -323,7 +323,7 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, int argc, ...)
 }
 
 mrb_value
-mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv, mrb_value blk)
+mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv, mrb_value blk)
 {
   mrb_value val;
 
@@ -413,7 +413,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, co
 }
 
 mrb_value
-mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, int argc, const mrb_value *argv)
+mrb_funcall_argv(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, const mrb_value *argv)
 {
   return mrb_funcall_with_block(mrb, self, mid, argc, argv, mrb_nil_value());
 }
@@ -442,7 +442,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self)
 {
   mrb_sym name;
   mrb_value block, *argv, *regs;
-  int argc, i, len;
+  mrb_int argc, i, len;
   struct RProc *p;
   struct RClass *c;
   mrb_callinfo *ci;
@@ -487,7 +487,7 @@ mrb_f_send(mrb_state *mrb, mrb_value self)
 }
 
 mrb_value
-mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv, mrb_value self, struct RClass *c)
+mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c)
 {
   struct RProc *p;
   mrb_sym mid = mrb->c->ci->mid;
@@ -534,7 +534,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, int argc, const mrb_value *arg
 }
 
 mrb_value
-mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, const mrb_value *argv)
+mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv)
 {
   struct RProc *p = mrb_proc_ptr(b);
 
@@ -572,7 +572,7 @@ localjump_error(mrb_state *mrb, localjump_error_kind kind)
 }
 
 static void
-argnum_error(mrb_state *mrb, int num)
+argnum_error(mrb_state *mrb, mrb_int num)
 {
   mrb_value exc;
   mrb_value str;