Reduce integer type mismatch warnings in VC.

include/mruby/debug.h

@@ -47,13 +47,13 @@ typedef struct mrb_irep_debug_info {
  * get line from irep's debug info and program counter
  * @return returns NULL if not found
  */
-MRB_API const char *mrb_debug_get_filename(mrb_irep *irep, uint32_t pc);
+MRB_API const char *mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc);
 
 /*
  * get line from irep's debug info and program counter
  * @return returns -1 if not found
  */
-MRB_API int32_t mrb_debug_get_line(mrb_irep *irep, uint32_t pc);
+MRB_API int32_t mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc);
 
 MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(
     mrb_state *mrb, mrb_irep *irep,

include/mruby/irep.h

@@ -44,7 +44,7 @@ typedef struct mrb_irep {
   uint16_t *lines;
   struct mrb_irep_debug_info* debug_info;
 
-  size_t ilen, plen, slen, rlen, refcnt;
+  int ilen, plen, slen, rlen, refcnt;
 
   struct RProc *outer;      /* Refers outer scope */
 } mrb_irep;

mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c

@@ -429,7 +429,7 @@ static mrb_bool
 check_start_pc_for_line(mrb_irep *irep, mrb_code *pc, uint16_t line)
 {
   if (pc > irep->iseq) {
-    if (line == mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq - 1))) {
+    if (line == mrb_debug_get_line(irep, pc - irep->iseq - 1)) {
       return FALSE;
     }
   }

mrbgems/mruby-bin-debugger/tools/mrdb/cmdbreak.c

@@ -274,7 +274,7 @@ parse_breakcommand(mrdb_state *mrdb, const char **file, uint32_t *line, char **c
       STRTOUL(l, body);
       if (l <= 65535) {
         *line = l;
-        *file = (body == args)? mrb_debug_get_filename(dbg->irep, (uint32_t)(dbg->pc - dbg->irep->iseq)): args;
+        *file = (body == args)? mrb_debug_get_filename(dbg->irep, dbg->pc - dbg->irep->iseq): args;
       }
       else {
         puts(BREAK_ERR_MSG_RANGEOVER);

mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c

@@ -566,8 +566,8 @@ mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, mrb_code *pc, mrb_value *reg
     dbg->xphase = DBG_PHASE_RUNNING;
   }
 
-  file = mrb_debug_get_filename(irep, (uint32_t)(pc - irep->iseq));
-  line = mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq));
+  file = mrb_debug_get_filename(irep, pc - irep->iseq);
+  line = mrb_debug_get_line(irep, pc - irep->iseq);
 
   switch (dbg->xm) {
   case DBG_STEP:

mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c

@@ -16,7 +16,7 @@ struct strip_args {
 static void
 irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
 {
-  size_t i;
+  int i;
 
   if (irep->lv) {
     mrb_free(mrb, irep->lv);

mrbgems/mruby-compiler/core/codegen.c

@@ -66,9 +66,7 @@ typedef struct scope {
   int icapa;
 
   mrb_irep *irep;
-  size_t pcapa;
-  size_t scapa;
-  size_t rcapa;
+  int pcapa, scapa, rcapa;
 
   uint16_t nlocals;
   uint16_t nregs;
@@ -428,7 +426,7 @@ push_(codegen_scope *s)
 }
 
 static void
-push_n_(codegen_scope *s, size_t n)
+push_n_(codegen_scope *s, int n)
 {
   if (s->sp+n > 511) {
     codegen_error(s, "too complex expression");
@@ -447,7 +445,7 @@ push_n_(codegen_scope *s, size_t n)
 static inline int
 new_lit(codegen_scope *s, mrb_value val)
 {
-  size_t i;
+  int i;
   mrb_value *pv;
 
   switch (mrb_type(val)) {
@@ -518,7 +516,7 @@ new_lit(codegen_scope *s, mrb_value val)
 static int
 new_msym(codegen_scope *s, mrb_sym sym)
 {
-  size_t i, len;
+  int i, len;
 
   mrb_assert(s->irep);
 
@@ -539,7 +537,7 @@ new_msym(codegen_scope *s, mrb_sym sym)
 static int
 new_sym(codegen_scope *s, mrb_sym sym)
 {
-  size_t i;
+  int i;
 
   for (i=0; i<s->irep->slen; i++) {
     if (s->irep->syms[i] == sym) return i;
@@ -573,8 +571,8 @@ node_len(node *tree)
   return n;
 }
 
-#define sym(x) ((mrb_sym)(intptr_t)(x))
-#define lv_name(lv) sym((lv)->car)
+#define nsym(x) ((mrb_sym)(intptr_t)(x))
+#define lv_name(lv) nsym((lv)->car)
 static int
 lv_idx(codegen_scope *s, mrb_sym id)
 {
@@ -701,7 +699,7 @@ lambda_body(codegen_scope *s, node *tree, int blk)
 
       dispatch(s, pos+i);
       codegen(s, opt->car->cdr, VAL);
-      idx = lv_idx(s, (mrb_sym)(intptr_t)opt->car->car);
+      idx = lv_idx(s, nsym(opt->car->car));
       pop();
       genop_peep(s, MKOP_AB(OP_MOVE, idx, cursp()), NOVAL);
       i++;
@@ -764,11 +762,14 @@ scope_body(codegen_scope *s, node *tree, int val)
   return s->irep->rlen - 1;
 }
 
+#define nint(x) ((int)(intptr_t)(x))
+#define nchar(x) ((char)(intptr_t)(x))
+
 static mrb_bool
 nosplat(node *t)
 {
   while (t) {
-    if ((intptr_t)t->car->car == NODE_SPLAT) return FALSE;
+    if (nint(t->car->car) == NODE_SPLAT) return FALSE;
     t = t->cdr;
   }
   return TRUE;
@@ -804,12 +805,12 @@ gen_values(codegen_scope *s, node *t, int val, int extra)
   int is_splat;
 
   while (t) {
-    is_splat = (intptr_t)t->car->car == NODE_SPLAT; /* splat mode */
+    is_splat = nint(t->car->car) == NODE_SPLAT; /* splat mode */
     if (
       n+extra >= CALL_MAXARGS - 1 /* need to subtract one because vm.c expects an array if n == CALL_MAXARGS */
       || is_splat) {
       if (val) {
-        if (is_splat && n == 0 && (intptr_t)t->car->cdr->car == NODE_ARRAY) {
+        if (is_splat && n == 0 && nint(t->car->cdr->car) == NODE_ARRAY) {
           codegen(s, t->car->cdr, VAL);
           pop();
         }
@@ -831,7 +832,7 @@ gen_values(codegen_scope *s, node *t, int val, int extra)
           push();
           codegen(s, t->car, VAL);
           pop(); pop();
-          if ((intptr_t)t->car->car == NODE_SPLAT) {
+          if (nint(t->car->car) == NODE_SPLAT) {
             genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
           }
           else {
@@ -859,7 +860,7 @@ gen_values(codegen_scope *s, node *t, int val, int extra)
 static void
 gen_call(codegen_scope *s, node *tree, mrb_sym name, int sp, int val, int safe)
 {
-  mrb_sym sym = name ? name : sym(tree->cdr->car);
+  mrb_sym sym = name ? name : nsym(tree->cdr->car);
   int idx, skip = 0;
   int n = 0, noop = 0, sendv = 0, blk = 0;
 
@@ -959,16 +960,16 @@ static void
 gen_assignment(codegen_scope *s, node *tree, int sp, int val)
 {
   int idx;
-  int type = (intptr_t)tree->car;
+  int type = nint(tree->car);
 
   tree = tree->cdr;
   switch (type) {
   case NODE_GVAR:
-    idx = new_sym(s, sym(tree));
+    idx = new_sym(s, nsym(tree));
     genop_peep(s, MKOP_ABx(OP_SETGLOBAL, sp, idx), val);
     break;
   case NODE_LVAR:
-    idx = lv_idx(s, sym(tree));
+    idx = lv_idx(s, nsym(tree));
     if (idx > 0) {
       if (idx != sp) {
         genop_peep(s, MKOP_AB(OP_MOVE, idx, sp), val);
@@ -980,7 +981,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val)
       codegen_scope *up = s->prev;
 
       while (up) {
-        idx = lv_idx(up, sym(tree));
+        idx = lv_idx(up, nsym(tree));
         if (idx > 0) {
           genop_peep(s, MKOP_ABC(OP_SETUPVAR, sp, idx, lv), val);
           break;
@@ -991,19 +992,19 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val)
     }
     break;
   case NODE_IVAR:
-    idx = new_sym(s, sym(tree));
+    idx = new_sym(s, nsym(tree));
     genop_peep(s, MKOP_ABx(OP_SETIV, sp, idx), val);
     break;
   case NODE_CVAR:
-    idx = new_sym(s, sym(tree));
+    idx = new_sym(s, nsym(tree));
     genop_peep(s, MKOP_ABx(OP_SETCV, sp, idx), val);
     break;
   case NODE_CONST:
-    idx = new_sym(s, sym(tree));
+    idx = new_sym(s, nsym(tree));
     genop_peep(s, MKOP_ABx(OP_SETCONST, sp, idx), val);
     break;
   case NODE_COLON2:
-    idx = new_sym(s, sym(tree->cdr));
+    idx = new_sym(s, nsym(tree->cdr));
     genop_peep(s, MKOP_AB(OP_MOVE, cursp(), sp), NOVAL);
     push();
     codegen(s, tree->car, VAL);
@@ -1014,7 +1015,7 @@ gen_assignment(codegen_scope *s, node *tree, int sp, int val)
   case NODE_CALL:
   case NODE_SCALL:
     push();
-    gen_call(s, tree, attrsym(s, sym(tree->cdr->car)), sp, NOVAL,
+    gen_call(s, tree, attrsym(s, nsym(tree->cdr->car)), sp, NOVAL,
              type == NODE_SCALL);
     pop();
     if (val) {
@@ -1105,9 +1106,9 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
     int i = 0, j = 0;
 
     while (tree) {
-      switch ((intptr_t)tree->car->car) {
+      switch (nint(tree->car->car)) {
       case NODE_STR:
-        if ((tree->cdr == NULL) && ((intptr_t)tree->car->cdr->cdr == 0))
+        if ((tree->cdr == NULL) && (nint(tree->car->cdr->cdr) == 0))
           break;
         /* fall through */
       case NODE_BEGIN:
@@ -1143,7 +1144,7 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
   }
   else {
     while (tree) {
-      switch ((intptr_t)tree->car->car) {
+      switch (nint(tree->car->car)) {
       case NODE_BEGIN: case NODE_BLOCK:
         codegen(s, tree->car, NOVAL);
       }
@@ -1232,7 +1233,7 @@ readint_mrb_int(codegen_scope *s, const char *p, int base, mrb_bool neg, mrb_boo
 static void
 gen_retval(codegen_scope *s, node *tree)
 {
-  if ((intptr_t)tree->car == NODE_SPLAT) {
+  if (nint(tree->car) == NODE_SPLAT) {
     genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), 0));
     push();
     codegen(s, tree, VAL);
@@ -1271,7 +1272,7 @@ codegen(codegen_scope *s, node *tree, int val)
     s->filename = mrb_parser_get_filename(s->parser, tree->filename_index);
   }
 
-  nt = (intptr_t)tree->car;
+  nt = nint(tree->car);
   s->lineno = tree->lineno;
   tree = tree->cdr;
   switch (nt) {
@@ -1316,7 +1317,7 @@ codegen(codegen_scope *s, node *tree, int val)
           if (pos1) dispatch(s, pos1);
           pos2 = 0;
           do {
-            if (n4 && n4->car && (intptr_t)n4->car->car == NODE_SPLAT) {
+            if (n4 && n4->car && nint(n4->car->car) == NODE_SPLAT) {
               codegen(s, n4->car, VAL);
               genop(s, MKOP_AB(OP_MOVE, cursp(), exc));
               pop();
@@ -1377,7 +1378,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_ENSURE:
     if (!tree->cdr || !tree->cdr->cdr ||
-        ((intptr_t)tree->cdr->cdr->car == NODE_BEGIN &&
+        (nint(tree->cdr->cdr->car) == NODE_BEGIN &&
          tree->cdr->cdr->cdr)) {
       int idx;
       int epush = s->pc;
@@ -1422,7 +1423,7 @@ codegen(codegen_scope *s, node *tree, int val)
         codegen(s, e, val);
         goto exit;
       }
-      switch ((intptr_t)tree->car->car) {
+      switch (nint(tree->car->car)) {
       case NODE_TRUE:
       case NODE_INT:
       case NODE_STR:
@@ -1542,7 +1543,7 @@ codegen(codegen_scope *s, node *tree, int val)
           if (head) {
             genop(s, MKOP_AB(OP_MOVE, cursp(), head));
             pop();
-            if ((intptr_t)n->car->car == NODE_SPLAT) {
+            if (nint(n->car->car) == NODE_SPLAT) {
               genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1));
             }
             else {
@@ -1622,7 +1623,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_COLON2:
     {
-      int sym = new_sym(s, sym(tree->cdr));
+      int sym = new_sym(s, nsym(tree->cdr));
 
       codegen(s, tree->car, VAL);
       pop();
@@ -1633,7 +1634,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_COLON3:
     {
-      int sym = new_sym(s, sym(tree));
+      int sym = new_sym(s, nsym(tree));
 
       genop(s, MKOP_A(OP_OCLASS, cursp()));
       genop(s, MKOP_ABx(OP_GETMCNST, cursp(), sym));
@@ -1709,7 +1710,7 @@ codegen(codegen_scope *s, node *tree, int val)
       node *t = tree->cdr, *p;
       int rhs = cursp();
 
-      if ((intptr_t)t->car == NODE_ARRAY && t->cdr && nosplat(t->cdr)) {
+      if (nint(t->car) == NODE_ARRAY && t->cdr && nosplat(t->cdr)) {
         /* fixed rhs */
         t = t->cdr;
         while (t) {
@@ -1783,14 +1784,14 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_OP_ASGN:
     {
-      mrb_sym sym = sym(tree->cdr->car);
+      mrb_sym sym = nsym(tree->cdr->car);
       mrb_int len;
       const char *name = mrb_sym2name_len(s->mrb, sym, &len);
       int idx, callargs = -1, vsp = -1;
 
       if ((len == 2 && name[0] == '|' && name[1] == '|') &&
-          ((intptr_t)tree->car->car == NODE_CONST ||
-           (intptr_t)tree->car->car == NODE_CVAR)) {
+          (nint(tree->car->car) == NODE_CONST ||
+           nint(tree->car->car) == NODE_CVAR)) {
         int onerr, noexc, exc;
         struct loopinfo *lp;
 
@@ -1808,7 +1809,7 @@ codegen(codegen_scope *s, node *tree, int val)
         dispatch(s, noexc);
         loop_pop(s, NOVAL);
       }
-      else if ((intptr_t)tree->car->car == NODE_CALL) {
+      else if (nint(tree->car->car) == NODE_CALL) {
         node *n = tree->car->cdr;
 
         if (val) {
@@ -1816,7 +1817,7 @@ codegen(codegen_scope *s, node *tree, int val)
           push();
         }
         codegen(s, n->car, VAL);   /* receiver */
-        idx = new_msym(s, sym(n->cdr->car));
+        idx = new_msym(s, nsym(n->cdr->car));
         if (n->cdr->cdr->car) {
           int base = cursp()-1;
           int nargs = gen_values(s, n->cdr->cdr->car->car, VAL, 1);
@@ -1872,8 +1873,8 @@ codegen(codegen_scope *s, node *tree, int val)
         if (val && vsp >= 0) {
           genop(s, MKOP_AB(OP_MOVE, vsp, cursp()));
         }
-        if ((intptr_t)tree->car->car == NODE_CALL) {
-          mrb_sym m = sym(tree->car->cdr->cdr->car);
+        if (nint(tree->car->car) == NODE_CALL) {
+          mrb_sym m = nsym(tree->car->cdr->cdr->car);
           mrb_sym m2 = attrsym(s, m);
 
           idx = new_msym(s, m2);
@@ -1942,7 +1943,7 @@ codegen(codegen_scope *s, node *tree, int val)
           callargs++;
         }
         pop();
-        idx = new_msym(s, attrsym(s,sym(tree->car->cdr->cdr->car)));
+        idx = new_msym(s, attrsym(s,nsym(tree->car->cdr->cdr->car)));
         genop(s, MKOP_ABC(OP_SEND, cursp(), idx, callargs));
       }
     }
@@ -2134,7 +2135,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_LVAR:
     if (val) {
-      int idx = lv_idx(s, sym(tree));
+      int idx = lv_idx(s, nsym(tree));
 
       if (idx > 0) {
         genop_peep(s, MKOP_AB(OP_MOVE, cursp(), idx), NOVAL);
@@ -2144,7 +2145,7 @@ codegen(codegen_scope *s, node *tree, int val)
         codegen_scope *up = s->prev;
 
         while (up) {
-          idx = lv_idx(up, sym(tree));
+          idx = lv_idx(up, nsym(tree));
           if (idx > 0) {
             genop(s, MKOP_ABC(OP_GETUPVAR, cursp(), idx, lv));
             break;
@@ -2159,7 +2160,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_GVAR:
     if (val) {
-      int sym = new_sym(s, sym(tree));
+      int sym = new_sym(s, nsym(tree));
 
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
@@ -2168,7 +2169,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_IVAR:
     if (val) {
-      int sym = new_sym(s, sym(tree));
+      int sym = new_sym(s, nsym(tree));
 
       genop(s, MKOP_ABx(OP_GETIV, cursp(), sym));
       push();
@@ -2177,7 +2178,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_CVAR:
     if (val) {
-      int sym = new_sym(s, sym(tree));
+      int sym = new_sym(s, nsym(tree));
 
       genop(s, MKOP_ABx(OP_GETCV, cursp(), sym));
       push();
@@ -2186,7 +2187,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_CONST:
     {
-      int sym = new_sym(s, sym(tree));
+      int sym = new_sym(s, nsym(tree));
 
       genop(s, MKOP_ABx(OP_GETCONST, cursp(), sym));
       if (val) {
@@ -2205,7 +2206,7 @@ codegen(codegen_scope *s, node *tree, int val)
       int sym;
 
       buf[0] = '$';
-      buf[1] = (char)(intptr_t)tree;
+      buf[1] = nchar(tree);
       buf[2] = 0;
       sym = new_sym(s, mrb_intern_cstr(s->mrb, buf));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
@@ -2219,7 +2220,7 @@ codegen(codegen_scope *s, node *tree, int val)
       mrb_value str;
       int sym;
 
-      str = mrb_format(mrb, "$%S", mrb_fixnum_value((mrb_int)(intptr_t)tree));
+      str = mrb_format(mrb, "$%S", mrb_fixnum_value(nint(tree)));
       sym = new_sym(s, mrb_intern_str(mrb, str));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
@@ -2237,7 +2238,7 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_INT:
     if (val) {
       char *p = (char*)tree->car;
-      int base = (intptr_t)tree->cdr->car;
+      int base = nint(tree->cdr->car);
       mrb_int i;
       mrb_code co;
       mrb_bool overflow;
@@ -2276,7 +2277,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_NEGATE:
     {
-      nt = (intptr_t)tree->car;
+      nt = nint(tree->car);
       tree = tree->cdr;
       switch (nt) {
       case NODE_FLOAT:
@@ -2293,7 +2294,7 @@ codegen(codegen_scope *s, node *tree, int val)
       case NODE_INT:
         if (val) {
           char *p = (char*)tree->car;
-          int base = (intptr_t)tree->cdr->car;
+          int base = nint(tree->cdr->car);
           mrb_int i;
           mrb_code co;
           mrb_bool overflow;
@@ -2376,7 +2377,7 @@ codegen(codegen_scope *s, node *tree, int val)
       node *n = tree;
 
       while (n) {
-        if ((intptr_t)n->car->car != NODE_STR) {
+        if (nint(n->car->car) != NODE_STR) {
           codegen(s, n->car, NOVAL);
         }
         n = n->cdr;
@@ -2403,7 +2404,7 @@ codegen(codegen_scope *s, node *tree, int val)
       codegen(s, tree->car, VAL);
       n = tree->cdr;
       while (n) {
-        if ((intptr_t)n->car->car == NODE_XSTR) {
+        if (nint(n->car->car) == NODE_XSTR) {
           n->car->car = (struct mrb_ast_node*)(intptr_t)NODE_STR;
           mrb_assert(!n->cdr); /* must be the end */
         }
@@ -2539,7 +2540,7 @@ codegen(codegen_scope *s, node *tree, int val)
       node *n = tree->car;
 
       while (n) {
-        if ((intptr_t)n->car->car != NODE_STR) {
+        if (nint(n->car->car) != NODE_STR) {
           codegen(s, n->car, NOVAL);
         }
         n = n->cdr;
@@ -2549,7 +2550,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_SYM:
     if (val) {
-      int sym = new_sym(s, sym(tree));
+      int sym = new_sym(s, nsym(tree));
 
       genop(s, MKOP_ABx(OP_LOADSYM, cursp(), sym));
       push();
@@ -2593,8 +2594,8 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_ALIAS:
     {
-      int a = new_msym(s, sym(tree->car));
-      int b = new_msym(s, sym(tree->cdr));
+      int a = new_msym(s, nsym(tree->car));
+      int b = new_msym(s, nsym(tree->cdr));
       int c = new_msym(s, mrb_intern_lit(s->mrb, "alias_method"));
 
       genop(s, MKOP_A(OP_TCLASS, cursp()));
@@ -2627,7 +2628,7 @@ codegen(codegen_scope *s, node *tree, int val)
           pop_n(num);
           genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), num));
           while (t) {
-            symbol = new_msym(s, sym(t->car));
+            symbol = new_msym(s, nsym(t->car));
             push();
             genop(s, MKOP_ABx(OP_LOADSYM, cursp(), symbol));
             pop();
@@ -2637,7 +2638,7 @@ codegen(codegen_scope *s, node *tree, int val)
           num = CALL_MAXARGS;
           break;
         }
-        symbol = new_msym(s, sym(t->car));
+        symbol = new_msym(s, nsym(t->car));
         genop(s, MKOP_ABx(OP_LOADSYM, cursp(), symbol));
         push();
         t = t->cdr;
@@ -2677,7 +2678,7 @@ codegen(codegen_scope *s, node *tree, int val)
         push();
       }
       pop(); pop();
-      idx = new_msym(s, sym(tree->car->cdr));
+      idx = new_msym(s, nsym(tree->car->cdr));
       genop(s, MKOP_AB(OP_CLASS, cursp(), idx));
       idx = scope_body(s, tree->cdr->cdr->car, val);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
@@ -2703,7 +2704,7 @@ codegen(codegen_scope *s, node *tree, int val)
         codegen(s, tree->car->car, VAL);
       }
       pop();
-      idx = new_msym(s, sym(tree->car->cdr));
+      idx = new_msym(s, nsym(tree->car->cdr));
       genop(s, MKOP_AB(OP_MODULE, cursp(), idx));
       idx = scope_body(s, tree->cdr->car, val);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
@@ -2730,7 +2731,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
   case NODE_DEF:
     {
-      int sym = new_msym(s, sym(tree->car));
+      int sym = new_msym(s, nsym(tree->car));
       int idx = lambda_body(s, tree->cdr, 0);
 
       genop(s, MKOP_A(OP_TCLASS, cursp()));
@@ -2749,7 +2750,7 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_SDEF:
     {
       node *recv = tree->car;
-      int sym = new_msym(s, sym(tree->cdr->car));
+      int sym = new_msym(s, nsym(tree->cdr->car));
       int idx = lambda_body(s, tree->cdr->cdr, 0);
 
       codegen(s, recv, VAL);

mrbgems/mruby-eval/src/eval.c

@@ -44,7 +44,7 @@ get_closure_irep(mrb_state *mrb, int level)
 static mrb_irep*
 search_irep(mrb_irep *top, int bnest, int lev, mrb_irep *bottom)
 {
-  size_t i;
+  int i;
 
   for (i=0; i<top->rlen; i++) {
     mrb_irep* tmp = top->reps[i];
@@ -106,7 +106,7 @@ potential_upvar_p(struct mrb_locals *lv, uint16_t v, int argc, uint16_t nlocals)
 static void
 patch_irep(mrb_state *mrb, mrb_irep *irep, int bnest, mrb_irep *top)
 {
-  size_t i;
+  int i;
   mrb_code c;
   int argc = irep_argc(irep);
 

mrbgems/mruby-sprintf/src/sprintf.c

@@ -128,7 +128,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
 #define PUSH(s, l) do { \
   CHECK(l);\
   memcpy(&buf[blen], s, l);\
-  blen += (l);\
+  blen += (mrb_int)(l);\
 } while (0)
 
 #define FILL(c, l) do { \
@@ -765,7 +765,7 @@ retry:
           if ((flags&FPREC) && (prec < slen)) {
             char *p = RSTRING_PTR(str) + prec;
             slen = prec;
-            len = p - RSTRING_PTR(str);
+            len = (mrb_int)(p - RSTRING_PTR(str));
           }
           /* need to adjust multi-byte string pos */
           if ((flags&FWIDTH) && (width > slen)) {

src/backtrace.c

@@ -56,8 +56,8 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, mrb_code *pc0, each_backtrace_fu
     else {
       pc = pc0;
     }
-    loc.filename = mrb_debug_get_filename(irep, (uint32_t)(pc - irep->iseq));
-    loc.lineno = mrb_debug_get_line(irep, (uint32_t)(pc - irep->iseq));
+    loc.filename = mrb_debug_get_filename(irep, pc - irep->iseq);
+    loc.lineno = mrb_debug_get_line(irep, pc - irep->iseq);
 
     if (loc.lineno == -1) continue;
 

src/codedump.c

@@ -459,7 +459,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
 static void
 codedump_recur(mrb_state *mrb, mrb_irep *irep)
 {
-  size_t i;
+  int i;
 
   codedump(mrb, irep);
   for (i=0; i<irep->rlen; i++) {

src/debug.c

@@ -51,7 +51,7 @@ select_line_type(const uint16_t *lines, size_t lines_len)
 }
 
 MRB_API char const*
-mrb_debug_get_filename(mrb_irep *irep, uint32_t pc)
+mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc)
 {
   if (irep && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;
@@ -64,7 +64,7 @@ mrb_debug_get_filename(mrb_irep *irep, uint32_t pc)
 }
 
 MRB_API int32_t
-mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
+mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc)
 {
   if (irep && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;

src/dump.c

@@ -79,7 +79,7 @@ static ptrdiff_t
 write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
 {
   uint8_t *cur = buf;
-  uint32_t iseq_no;
+  int iseq_no;
 
   cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
   cur += write_padding(cur);
@@ -111,8 +111,8 @@ write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
 static size_t
 get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
 {
+  int pool_no;
   size_t size = 0;
-  size_t pool_no;
   mrb_value str;
 
   size += sizeof(uint32_t); /* plen */
@@ -160,7 +160,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
 static ptrdiff_t
 write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 {
-  size_t pool_no;
+  int pool_no;
   uint8_t *cur = buf;
   uint16_t len;
   mrb_value str;
@@ -213,7 +213,7 @@ static size_t
 get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t size = 0;
-  uint32_t sym_no;
+  int sym_no;
   mrb_int len;
 
   size += sizeof(uint32_t); /* slen */
@@ -231,7 +231,7 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
 static ptrdiff_t
 write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 {
-  uint32_t sym_no;
+  int sym_no;
   uint8_t *cur = buf;
   const char *name;
 
@@ -273,7 +273,7 @@ static size_t
 get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t size = 0;
-  size_t irep_no;
+  int irep_no;
 
   size = get_irep_record_size_1(mrb, irep);
   for (irep_no = 0; irep_no < irep->rlen; irep_no++) {
@@ -285,7 +285,7 @@ get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
 static int
 write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
 {
-  uint32_t i;
+  int i;
   uint8_t *src = bin;
 
   if (irep == NULL) {
@@ -399,7 +399,7 @@ static size_t
 write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 {
   uint8_t *cur = bin;
-  size_t iseq_no;
+  int iseq_no;
   size_t filename_len;
   ptrdiff_t diff;
 
@@ -442,8 +442,8 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 static size_t
 write_lineno_record(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 {
-  size_t i;
   size_t rlen, size = 0;
+  int i;
 
   rlen = write_lineno_record_1(mrb, irep, bin);
   bin += rlen;
@@ -483,7 +483,7 @@ get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
 {
   size_t ret = 0;
   uint16_t f_idx;
-  size_t i;
+  int i;
 
   ret += sizeof(uint32_t); /* record size */
   ret += sizeof(uint16_t); /* file count */
@@ -531,8 +531,9 @@ static size_t
 get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
 {
   mrb_sym *filenames = *fp;
-  size_t i, size = 0;
+  size_t size = 0;
   mrb_irep_debug_info *di = irep->debug_info;
+  int i;
 
   mrb_assert(lp);
   for (i = 0; i < di->flen; ++i) {
@@ -615,7 +616,7 @@ static size_t
 write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
 {
   size_t size, len;
-  size_t irep_no;
+  int irep_no;
 
   size = len = write_debug_record_1(mrb, irep, bin, filenames, filenames_len);
   bin += len;
@@ -673,7 +674,7 @@ write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const
 static void
 create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32_t *syms_len)
 {
-  size_t i;
+  int i;
 
   if (*syms == NULL) {
     *syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * 1);
@@ -720,7 +721,7 @@ static int
 write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym const *syms, uint32_t syms_len)
 {
   uint8_t *cur = *start;
-  size_t i;
+  int i;
 
   for (i = 0; i + 1 < irep->nlocals; ++i) {
     if (irep->lv[i].name == 0) {
@@ -748,7 +749,8 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c
 static size_t
 get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
 {
-  size_t ret = 0, i;
+  size_t ret = 0;
+  int i;
 
   ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1);
 
@@ -851,7 +853,7 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8
 static mrb_bool
 is_debug_info_defined(mrb_irep *irep)
 {
-  size_t i;
+  int i;
 
   if (!irep->debug_info) return FALSE;
   for (i=0; i<irep->rlen; i++) {
@@ -863,7 +865,7 @@ is_debug_info_defined(mrb_irep *irep)
 static mrb_bool
 is_lv_defined(mrb_irep *irep)
 {
-  size_t i;
+  int i;
 
   if (irep->lv) { return TRUE; }
 

src/error.c

@@ -207,8 +207,8 @@ exc_debug_info(mrb_state *mrb, struct RObject *exc)
     if (err && ci->proc && !MRB_PROC_CFUNC_P(ci->proc)) {
       mrb_irep *irep = ci->proc->body.irep;
 
-      int32_t const line = mrb_debug_get_line(irep, (uint32_t)(err - irep->iseq));
-      char const* file = mrb_debug_get_filename(irep, (uint32_t)(err - irep->iseq));
+      int32_t const line = mrb_debug_get_line(irep, err - irep->iseq);
+      char const* file = mrb_debug_get_filename(irep, err - irep->iseq);
       if (line != -1 && file) {
         mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "file"), mrb_str_new_cstr(mrb, file));
         mrb_obj_iv_set(mrb, exc, mrb_intern_lit(mrb, "line"), mrb_fixnum_value(line));

src/fmt_fp.c

@@ -61,7 +61,7 @@ out(struct fmt_args *f, const char *s, size_t l)
 
 #define PAD_SIZE 256
 static void
-pad(struct fmt_args *f, char c, int w, int l, int fl)
+pad(struct fmt_args *f, char c, int w, int l, uint8_t fl)
 {
   char pad[PAD_SIZE];
   if (fl & (LEFT_ADJ | ZERO_PAD) || l >= w) return;
@@ -91,13 +91,14 @@ typedef char compiler_defines_long_double_incorrectly[9-(int)sizeof(long double)
 #endif
 
 static int
-fmt_fp(struct fmt_args *f, long double y, int w, int p, int fl, int t)
+fmt_fp(struct fmt_args *f, long double y, int w, int p, uint8_t fl, int t)
 {
   uint32_t big[(LDBL_MANT_DIG+28)/29 + 1          // mantissa expansion
     + (LDBL_MAX_EXP+LDBL_MANT_DIG+28+8)/9]; // exponent expansion
   uint32_t *a, *d, *r, *z;
   uint32_t i;
-  int e2=0, e, j, l;
+  int e2=0, e, j;
+  ptrdiff_t l;
   char buf[9+LDBL_MANT_DIG/4], *s;
   const char *prefix="-0X+0X 0X-0x+0x 0x";
   int pl;

src/load.c

@@ -24,7 +24,7 @@
 #define FLAG_SRC_MALLOC 1
 #define FLAG_SRC_STATIC 0
 
-#define SIZE_ERROR_MUL(nmemb, size) ((nmemb) > SIZE_MAX / (size))
+#define SIZE_ERROR_MUL(nmemb, size) ((size_t)(nmemb) > SIZE_MAX / (size))
 
 static size_t
 skip_padding(const uint8_t *buf)
@@ -43,11 +43,11 @@ offset_crc_body(void)
 static mrb_irep*
 read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
 {
-  size_t i;
+  int i;
   const uint8_t *src = bin;
   ptrdiff_t diff;
   uint16_t tt, pool_data_len, snl;
-  size_t plen;
+  int plen;
   int ai = mrb_gc_arena_save(mrb);
   mrb_irep *irep = mrb_add_irep(mrb);
 
@@ -104,7 +104,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
   }
 
   /* POOL BLOCK */
-  plen = (size_t)bin_to_uint32(src); /* number of pool */
+  plen = bin_to_uint32(src); /* number of pool */
   src += sizeof(uint32_t);
   if (plen > 0) {
     if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) {
@@ -191,7 +191,7 @@ static mrb_irep*
 read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
 {
   mrb_irep *irep = read_irep_record_1(mrb, bin, len, flags);
-  size_t i;
+  int i;
 
   if (irep == NULL) {
     return NULL;
@@ -262,7 +262,7 @@ static int
 read_lineno_record(mrb_state *mrb, const uint8_t *bin, mrb_irep *irep, size_t *lenp)
 {
   int result = read_lineno_record_1(mrb, bin, irep, lenp);
-  size_t i;
+  int i;
 
   if (result != MRB_DUMP_OK) return result;
   for (i = 0; i < irep->rlen; i++) {
@@ -293,13 +293,14 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
 {
   const uint8_t *bin = start;
   ptrdiff_t diff;
-  size_t record_size, i;
+  size_t record_size;
   uint16_t f_idx;
+  int i;
 
   if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
 
   irep->debug_info = (mrb_irep_debug_info*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info));
-  irep->debug_info->pc_count = irep->ilen;
+  irep->debug_info->pc_count = (uint32_t)irep->ilen;
 
   record_size = (size_t)bin_to_uint32(bin);
   bin += sizeof(uint32_t);
@@ -432,8 +433,8 @@ static int
 read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len)
 {
   const uint8_t *bin = start;
-  size_t i;
   ptrdiff_t diff;
+  int i;
 
   irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
 

src/state.c

@@ -137,7 +137,7 @@ mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
 void
 mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
 {
-  size_t i;
+  int i;
 
   if (!(irep->flags & MRB_ISEQ_NO_FREE))
     mrb_free(mrb, irep->iseq);