Merge pull request #1843 from take-cheeze/suppress_warnings

Suppress warnings.

include/mruby/debug.h

@@ -28,10 +28,10 @@ typedef struct mrb_irep_debug_info_file {
   uint32_t line_entry_count;
   mrb_debug_line_type line_type;
   union {
-    void *line_ptr;
-    mrb_irep_debug_info_line *line_flat_map;
-    uint16_t *line_ary;
-  };
+    void *ptr;
+    mrb_irep_debug_info_line *flat_map;
+    uint16_t *ary;
+  } lines;
 } mrb_irep_debug_info_file;
 
 typedef struct mrb_irep_debug_info {

mrbgems/mruby-random/src/mt19937ar.c

@@ -63,7 +63,7 @@ unsigned long mrb_random_genrand_int32(mt_state *t)
     y ^= (y << 15) & 0xefc60000UL;
     y ^= (y >> 18);
     
-    t->gen_int = y;
+    t->gen.int_ = y;
 
     return y;
 }
@@ -71,8 +71,8 @@ unsigned long mrb_random_genrand_int32(mt_state *t)
 double mrb_random_genrand_real1(mt_state *t)
 {
     mrb_random_genrand_int32(t);
-    t->gen_dbl =  t->gen_int*(1.0/4294967295.0); 
-    return t->gen_dbl;
+    t->gen.double_ =  t->gen.int_*(1.0/4294967295.0); 
+    return t->gen.double_;
     /* divided by 2^32-1 */ 
 }
 

mrbgems/mruby-random/src/mt19937ar.h

@@ -10,9 +10,9 @@ typedef struct {
   unsigned long mt[N];
   int mti;
   union {
-    unsigned long gen_int;
-    double gen_dbl;
-  };
+    unsigned long int_;
+    double double_;
+  } gen;
 
   mrb_int seed;
   mrb_bool has_seed : 1;

src/debug.c

@@ -74,11 +74,11 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
       switch(f->line_type) {
         case mrb_debug_line_ary:
           mrb_assert(f->start_pos <= pc && pc < (f->start_pos + f->line_entry_count));
-          return f->line_ary[pc - f->start_pos];
+          return f->lines.ary[pc - f->start_pos];
 
         case mrb_debug_line_flat_map: {
           /* get upper bound */
-          mrb_irep_debug_info_line *ret = f->line_flat_map;
+          mrb_irep_debug_info_line *ret = f->lines.flat_map;
           uint32_t count = f->line_entry_count;
           while (count > 0) {
             int32_t step = count / 2;
@@ -92,10 +92,10 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
           --ret;
 
           /* check line entry pointer range */
-          mrb_assert(f->line_flat_map <= ret && ret < (f->line_flat_map + f->line_entry_count));
+          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->line_flat_map) < f->line_entry_count)
+                     pc < (((ret + 1 - f->lines.flat_map) < f->line_entry_count)
                            ? (ret+1)->start_pos : irep->debug_info->pc_count));
 
           return ret->line;
@@ -160,31 +160,31 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
   ret->filename = mrb_sym2name_len(mrb, ret->filename_sym, &len);
 
   ret->line_type = select_line_type(irep->lines + start_pos, end_pos - start_pos);
-  ret->line_ptr = NULL;
+  ret->lines.ptr = NULL;
 
   switch(ret->line_type) {
     case mrb_debug_line_ary:
       ret->line_entry_count = file_pc_count;
-      ret->line_ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
+      ret->lines.ary = (uint16_t*)mrb_malloc(mrb, sizeof(uint16_t) * file_pc_count);
       for(i = 0; i < file_pc_count; ++i) {
-        ret->line_ary[i] = irep->lines[start_pos + i];
+        ret->lines.ary[i] = irep->lines[start_pos + i];
       }
       break;
 
     case mrb_debug_line_flat_map: {
       uint16_t prev_line = 0;
       mrb_irep_debug_info_line m;
-      ret->line_flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
+      ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(mrb, sizeof(mrb_irep_debug_info_line) * 1);
       ret->line_entry_count = 0;
       for(i = 0; i < file_pc_count; ++i) {
         if(irep->lines[start_pos + i] == prev_line) { continue; }
 
-        ret->line_flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
-            mrb, ret->line_flat_map,
+        ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
+            mrb, ret->lines.flat_map,
             sizeof(mrb_irep_debug_info_line) * (ret->line_entry_count + 1));
         m.start_pos = start_pos + i;
         m.line = irep->lines[start_pos + i];
-        ret->line_flat_map[ret->line_entry_count] = m;
+        ret->lines.flat_map[ret->line_entry_count] = m;
 
         /* update */
         ++ret->line_entry_count;
@@ -207,7 +207,7 @@ mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d)
 
   for(i = 0; i < d->flen; ++i) {
     mrb_assert(d->files[i]);
-    mrb_free(mrb, d->files[i]->line_ptr);
+    mrb_free(mrb, d->files[i]->lines.ptr);
     mrb_free(mrb, d->files[i]);
   }
   mrb_free(mrb, d->files);

src/dump.c

@@ -578,15 +578,15 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
       case mrb_debug_line_ary: {
         uint32_t l;
         for (l = 0; l < file->line_entry_count; ++l) {
-          cur += uint16_to_bin(file->line_ary[l], cur);
+          cur += uint16_to_bin(file->lines.ary[l], cur);
         }
       } break;
 
       case mrb_debug_line_flat_map: {
         uint32_t line;
         for (line = 0; line < file->line_entry_count; ++line) {
-          cur += uint32_to_bin(file->line_flat_map[line].start_pos, cur);
-          cur += uint16_to_bin(file->line_flat_map[line].line, cur);
+          cur += uint32_to_bin(file->lines.flat_map[line].start_pos, cur);
+          cur += uint16_to_bin(file->lines.flat_map[line].line, cur);
         }
       } break;
 

src/load.c

@@ -324,9 +324,9 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
       case mrb_debug_line_ary: {
         uint32_t l;
 
-        file->line_ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count));
+        file->lines.ary = (uint16_t *)mrb_malloc(mrb, sizeof(uint16_t) * (size_t)(file->line_entry_count));
         for(l = 0; l < file->line_entry_count; ++l) {
-          file->line_ary[l] = bin_to_uint16(bin);
+          file->lines.ary[l] = bin_to_uint16(bin);
           bin += sizeof(uint16_t);
         }
       } break;
@@ -334,12 +334,12 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
       case mrb_debug_line_flat_map: {
         uint32_t l;
 
-        file->line_flat_map = (mrb_irep_debug_info_line*)mrb_malloc(
+        file->lines.flat_map = (mrb_irep_debug_info_line*)mrb_malloc(
             mrb, sizeof(mrb_irep_debug_info_line) * (size_t)(file->line_entry_count));
         for(l = 0; l < file->line_entry_count; ++l) {
-          file->line_flat_map[l].start_pos = bin_to_uint32(bin);
+          file->lines.flat_map[l].start_pos = bin_to_uint32(bin);
           bin += sizeof(uint32_t);
-          file->line_flat_map[l].line = bin_to_uint16(bin);
+          file->lines.flat_map[l].line = bin_to_uint16(bin);
           bin += sizeof(uint16_t);
         }
       } break;

src/parse.y

@@ -3526,8 +3526,8 @@ static int
 scan_hex(const int *start, int len, int *retlen)
 {
   static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
-  register const int *s = start;
-  register int retval = 0;
+  const int *s = start;
+  int retval = 0;
   char *tmp;
 
   /* mrb_assert(len <= 2) */
@@ -3932,7 +3932,7 @@ arg_ambiguous(parser_state *p)
 static int
 parser_yylex(parser_state *p)
 {
-  register int c;
+  int c;
   int space_seen = 0;
   int cmd_state;
   enum mrb_lex_state_enum last_state;