add a space after C reserved words

include/mruby/khash.h

@@ -209,7 +209,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     for (k = kh_begin(h); k != kh_end(h); k++) {                        \
       if (kh_exist(h, k)) {                                             \
         k2 = kh_put_##name(mrb, h2, kh_key(h, k));                      \
-        if(kh_is_map) kh_value(h2, k2) = kh_value(h, k);                \
+        if (kh_is_map) kh_value(h2, k2) = kh_value(h, k);               \
       }                                                                 \
     }                                                                   \
     return h2;                                                          \

mrbgems/mruby-fiber/src/fiber.c

@@ -221,7 +221,7 @@ fiber_eq(mrb_state *mrb, mrb_value self)
   mrb_value other;
   mrb_get_args(mrb, "o", &other);
 
-  if(mrb_type(other) != MRB_TT_FIBER) {
+  if (mrb_type(other) != MRB_TT_FIBER) {
     return mrb_false_value();
   }
   return mrb_bool_value(fiber_ptr(self) == fiber_ptr(other));

src/array.c

@@ -643,7 +643,7 @@ mrb_ary_splice(mrb_state *mrb, mrb_value ary, mrb_int head, mrb_int len, mrb_val
     value_move(a->ptr + head + argc, a->ptr + tail, a->len - tail);
   }
 
-  for(i = 0; i < argc; i++) {
+  for (i = 0; i < argc; i++) {
     *(a->ptr + head + i) = *(argv + i);
   }
 
@@ -993,7 +993,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
   char tail[] = { ']' };
 
   /* check recursive */
-  for(i=0; i<RARRAY_LEN(list); i++) {
+  for (i=0; i<RARRAY_LEN(list); i++) {
     if (mrb_obj_equal(mrb, ary, RARRAY_PTR(list)[i])) {
       return mrb_str_new_lit(mrb, "[...]");
     }
@@ -1004,7 +1004,7 @@ inspect_ary(mrb_state *mrb, mrb_value ary, mrb_value list)
   arystr = mrb_str_buf_new(mrb, 64);
   mrb_str_buf_cat(mrb, arystr, head, sizeof(head));
 
-  for(i=0; i<RARRAY_LEN(ary); i++) {
+  for (i=0; i<RARRAY_LEN(ary); i++) {
     int ai = mrb_gc_arena_save(mrb);
 
     if (i > 0) {
@@ -1049,7 +1049,7 @@ join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list)
   mrb_value result, val, tmp;
 
   /* check recursive */
-  for(i=0; i<RARRAY_LEN(list); i++) {
+  for (i=0; i<RARRAY_LEN(list); i++) {
     if (mrb_obj_equal(mrb, ary, RARRAY_PTR(list)[i])) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "recursive array join");
     }
@@ -1059,13 +1059,13 @@ join_ary(mrb_state *mrb, mrb_value ary, mrb_value sep, mrb_value list)
 
   result = mrb_str_buf_new(mrb, 64);
 
-  for(i=0; i<RARRAY_LEN(ary); i++) {
+  for (i=0; i<RARRAY_LEN(ary); i++) {
     if (i > 0 && !mrb_nil_p(sep)) {
       mrb_str_buf_cat(mrb, result, RSTRING_PTR(sep), RSTRING_LEN(sep));
     }
 
     val = RARRAY_PTR(ary)[i];
-    switch(mrb_type(val)) {
+    switch (mrb_type(val)) {
     case MRB_TT_ARRAY:
     ary_join:
       val = join_ary(mrb, val, sep, list);

src/codegen.c

@@ -2447,7 +2447,7 @@ scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
 
   /* debug setting */
   p->debug_start_pos = 0;
-  if(p->filename) {
+  if (p->filename) {
     mrb_debug_info_alloc(mrb, p->irep);
     p->irep->filename = p->filename;
     p->irep->lines = p->lines;

src/debug.c

@@ -9,7 +9,7 @@ get_file(mrb_irep_debug_info *info, uint32_t pc)
   mrb_irep_debug_info_file **ret;
   int32_t count;
 
-  if(pc >= info->pc_count) { return NULL; }
+  if (pc >= info->pc_count) { return NULL; }
   /* get upper bound */
   ret = info->files;
   count =  info->flen;
@@ -71,7 +71,7 @@ mrb_debug_get_line(mrb_irep *irep, uint32_t pc)
       return irep->lines? irep->lines[pc] : -1;
     }
     else if ((f = get_file(irep->debug_info, pc))) {
-      switch(f->line_type) {
+      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->lines.ary[pc - f->start_pos];
@@ -162,11 +162,11 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
   ret->line_type = select_line_type(irep->lines + start_pos, end_pos - start_pos);
   ret->lines.ptr = NULL;
 
-  switch(ret->line_type) {
+  switch (ret->line_type) {
     case mrb_debug_line_ary:
       ret->line_entry_count = 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) {
+      for (i = 0; i < file_pc_count; ++i) {
         ret->lines.ary[i] = irep->lines[start_pos + i];
       }
       break;
@@ -176,8 +176,8 @@ mrb_debug_info_append_file(mrb_state *mrb, mrb_irep *irep,
       mrb_irep_debug_info_line m;
       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; }
+      for (i = 0; i < file_pc_count; ++i) {
+        if (irep->lines[start_pos + i] == prev_line) { continue; }
 
         ret->lines.flat_map = (mrb_irep_debug_info_line*)mrb_realloc(
             mrb, ret->lines.flat_map,
@@ -203,9 +203,9 @@ mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d)
 {
   uint32_t i;
 
-  if(!d) { return; }
+  if (!d) { return; }
 
-  for(i = 0; i < d->flen; ++i) {
+  for (i = 0; i < d->flen; ++i) {
     mrb_assert(d->files[i]);
     mrb_free(mrb, d->files[i]->lines.ptr);
     mrb_free(mrb, d->files[i]);

src/dump.c

@@ -482,7 +482,7 @@ get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
     /* lines */
     ret += sizeof(uint32_t); /* entry count */
     ret += sizeof(uint8_t); /* line type */
-    switch(file->line_type) {
+    switch (file->line_type) {
       case mrb_debug_line_ary:
         ret += sizeof(uint16_t) * (size_t)(file->line_entry_count);
         break;
@@ -575,7 +575,7 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
     /* lines */
     cur += uint32_to_bin(file->line_entry_count, cur);
     cur += uint8_to_bin(file->line_type, cur);
-    switch(file->line_type) {
+    switch (file->line_type) {
       case mrb_debug_line_ary: {
         uint32_t l;
         for (l = 0; l < file->line_entry_count; ++l) {

src/load.c

@@ -285,7 +285,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
   size_t record_size, i;
   uint16_t f_idx;
 
-  if(irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
+  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;
@@ -320,12 +320,12 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
     bin += sizeof(uint32_t);
     file->line_type = (mrb_debug_line_type)bin_to_uint8(bin);
     bin += sizeof(uint8_t);
-    switch(file->line_type) {
+    switch (file->line_type) {
       case mrb_debug_line_ary: {
         uint32_t l;
 
         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) {
+        for (l = 0; l < file->line_entry_count; ++l) {
           file->lines.ary[l] = bin_to_uint16(bin);
           bin += sizeof(uint16_t);
         }
@@ -336,7 +336,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
 
         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) {
+        for (l = 0; l < file->line_entry_count; ++l) {
           file->lines.flat_map[l].start_pos = bin_to_uint32(bin);
           bin += sizeof(uint32_t);
           file->lines.flat_map[l].line = bin_to_uint16(bin);
@@ -352,7 +352,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
   mrb_assert(diff >= 0);
   mrb_assert((size_t)diff <= SIZE_MAX);
 
-  if(record_size != (size_t)diff) {
+  if (record_size != (size_t)diff) {
     return MRB_DUMP_GENERAL_FAILURE;
   }
 
@@ -392,7 +392,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, mrb_boo
   filenames_len = bin_to_uint16(bin);
   bin += sizeof(uint16_t);
   filenames = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (size_t)filenames_len);
-  for(i = 0; i < filenames_len; ++i) {
+  for (i = 0; i < filenames_len; ++i) {
     uint16_t f_len = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
     if (alloc) {
@@ -703,7 +703,7 @@ mrb_read_irep_file(mrb_state *mrb, FILE* fp)
         uint8_t* const bin = (uint8_t*)mrb_malloc(mrb, section_size);
 
         fseek(fp, fpos, SEEK_SET);
-        if(fread((char*)bin, section_size, 1, fp) != 1) {
+        if (fread((char*)bin, section_size, 1, fp) != 1) {
           mrb_free(mrb, bin);
           return NULL;
         }

src/parse.y

@@ -5315,8 +5315,8 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
   p->filename = mrb_sym2name_len(p->mrb, sym, NULL);
   p->lineno = (p->filename_table_length > 0)? 0 : 1;
 
-  for(i = 0; i < p->filename_table_length; ++i) {
-    if(p->filename_table[i] == sym) {
+  for (i = 0; i < p->filename_table_length; ++i) {
+    if (p->filename_table[i] == sym) {
       p->current_filename_index = i;
       return;
     }