remove -Wsign-compare warnings

src/codegen.c

@@ -719,7 +719,7 @@ attrsym(codegen_scope *s, mrb_sym a)
                                  + 1 /* '=' */
                                  + 1 /* '\0' */
                                  );
-  mrb_assert(len <= SIZE_MAX);
+  mrb_assert(len > 0);
   memcpy(name2, name, (size_t)len);
   name2[len] = '=';
   name2[len+1] = '\0';

src/debug.c

@@ -95,7 +95,7 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
           mrb_assert(f->lines.flat_map <= ret && ret < (f->lines.flat_map + f->line_entry_count));
           /* check pc range */
           mrb_assert(ret->start_pos <= pc &&
-                     pc < (((ret + 1 - f->lines.flat_map) < f->line_entry_count)
+                     pc < (((uint32_t)(ret + 1 - f->lines.flat_map) < f->line_entry_count)
                            ? (ret+1)->start_pos : irep->debug_info->pc_count));
 
           return ret->line;

src/dump.c

@@ -89,8 +89,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
       str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
       {
         mrb_int len = RSTRING_LEN(str);
-        mrb_assert(len >= 0);
-        mrb_assert(len <= SIZE_MAX);
+        mrb_assert(len >= 0 && (size_t)len <= SIZE_MAX);
         size += (size_t)len;
       }
       break;
@@ -99,8 +98,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
       {
         int len;
         len = mrb_float_to_str(buf, mrb_float(irep->pool[pool_no]));
-        mrb_assert(len >= 0);
-        mrb_assert(len <= SIZE_MAX);
+        mrb_assert(len >= 0 && (size_t)len <= SIZE_MAX);
         size += (size_t)len;
       }
       break;
@@ -108,8 +106,7 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
     case MRB_TT_STRING:
       {
         mrb_int len = RSTRING_LEN(irep->pool[pool_no]);
-        mrb_assert(len >= 0);
-        mrb_assert(len <= SIZE_MAX);
+        mrb_assert(len >= 0 && (size_t)len <= SIZE_MAX);
         size += (size_t)len;
       }
       break;
@@ -416,11 +413,11 @@ write_lineno_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t* bin)
 
   diff = cur - bin;
   mrb_assert(diff >= 0);
-  mrb_assert(diff <= UINT32_MAX);
+  mrb_assert((uint32_t)diff <= UINT32_MAX);
 
   uint32_to_bin((uint32_t)diff, bin); /* record size */
 
-  mrb_assert(diff <= SIZE_MAX);
+  mrb_assert((size_t)diff <= SIZE_MAX);
   return (size_t)diff;
 }
 
@@ -596,11 +593,10 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
   }
 
   ret = cur - bin;
-  mrb_assert(ret >= 0);
-  mrb_assert(ret <= UINT32_MAX);
+  mrb_assert(ret >= 0 && (uint32_t)ret <= UINT32_MAX);
   uint32_to_bin(ret, bin);
 
-  mrb_assert(ret <= SIZE_MAX);
+  mrb_assert(ret >= 0 && (size_t)ret <= SIZE_MAX);
   return (size_t)ret;
 }
 

src/load.c

@@ -156,8 +156,7 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, mrb_bool all
   irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*irep->rlen);
 
   diff = src - bin;
-  mrb_assert(diff >= 0);
-  mrb_assert(diff <= SIZE_MAX);
+  mrb_assert(diff >= 0 && (size_t)diff <= SIZE_MAX);
   *len = (size_t)diff;
 
   return irep;
@@ -334,8 +333,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
   }
 
   diff = bin - start;
-  mrb_assert(diff >= 0);
-  mrb_assert(diff <= SIZE_MAX);
+  mrb_assert(diff >= 0 && (size_t)diff <= SIZE_MAX);
 
   if (record_size != (size_t)diff) {
     return MRB_DUMP_GENERAL_FAILURE;
@@ -351,8 +349,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
   }
 
   diff = bin - start;
-  mrb_assert(diff >= 0);
-  mrb_assert(diff <= SIZE_MAX);
+  mrb_assert(diff >=0 && (size_t)diff <= SIZE_MAX);
   *record_len = (size_t)diff;
 
   return MRB_DUMP_OK;
@@ -394,8 +391,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_boo
 
   bin += len;
   diff = bin - start;
-  mrb_assert(diff >= 0);
-  mrb_assert(diff <= UINT32_MAX);
+  mrb_assert(diff >= 0 && (size_t)diff <= UINT32_MAX);
   if ((uint32_t)diff != bin_to_uint32(header->section_size)) {
     result = MRB_DUMP_GENERAL_FAILURE;
   }

src/string.c

@@ -32,11 +32,11 @@
   }\
 } while (0)
 #define RSTRING_EMBED_LEN(s) \
-  (size_t)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+  (mrb_int)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
 #define STR_EMBED_LEN(s)\
-  (size_t)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
 #define STR_PTR(s) ((STR_EMBED_P(s)) ? (s)->as.ary : (s)->as.heap.ptr)
-#define STR_LEN(s) ((STR_EMBED_P(s)) ? STR_EMBED_LEN(s) : (size_t)(s)->as.heap.len)
+#define STR_LEN(s) ((STR_EMBED_P(s)) ? STR_EMBED_LEN(s) : (s)->as.heap.len)
 
 const char mrb_digitmap[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 

src/symbol.c

@@ -401,7 +401,8 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   sp = RSTRING_PTR(str);
   RSTRING_PTR(str)[0] = ':';
   memcpy(sp+1, name, len);
-  if (!symname_p(name) || strlen(name) != len) {
+  mrb_assert(len > 0 && (size_t)len <= SIZE_MAX);
+  if (!symname_p(name) || strlen(name) != (size_t)len) {
     str = mrb_str_dump(mrb, str);
     sp = RSTRING_PTR(str);
     sp[0] = ':';