diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c
index 93c2d33a4..385ad5116 100644
--- a/mrbgems/mruby-array-ext/src/array.c
+++ b/mrbgems/mruby-array-ext/src/array.c
@@ -33,7 +33,7 @@ mrb_ary_assoc(mrb_state *mrb, mrb_value ary)
   mrb_value v;
   mrb_value k = mrb_get_arg1(mrb);
 
-  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+  for (i = 0; i < RARRAY_LEN(ary); i++) {
     v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
     if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
         mrb_equal(mrb, RARRAY_PTR(v)[0], k))
@@ -63,7 +63,7 @@ mrb_ary_rassoc(mrb_state *mrb, mrb_value ary)
   mrb_value v;
   mrb_value value = mrb_get_arg1(mrb);
 
-  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+  for (i = 0; i < RARRAY_LEN(ary); i++) {
     v = RARRAY_PTR(ary)[i];
     if (mrb_array_p(v) &&
         RARRAY_LEN(v) > 1 &&
@@ -167,9 +167,9 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
   ptr = ARY_PTR(a) + i;
   ary = mrb_ary_new_from_values(mrb, len, ptr);
 
-  for (j = i; j < alen - len; ++j) {
+  for (j = i; j < alen - len; j++) {
     *ptr = *(ptr+len);
-    ++ptr;
+    ptr++;
   }
 
   mrb_ary_resize(mrb, self, alen - len);
@@ -193,7 +193,7 @@ mrb_ary_compact(mrb_state *mrb, mrb_value self)
   mrb_int len = RARRAY_LEN(self);
   mrb_value *p = RARRAY_PTR(self);
 
-  for (mrb_int i = 0; i < len; ++i) {
+  for (mrb_int i = 0; i < len; i++) {
     if (!mrb_nil_p(p[i])) {
       mrb_ary_push(mrb, ary, p[i]);
     }
@@ -221,7 +221,7 @@ mrb_ary_compact_bang(mrb_state *mrb, mrb_value self)
   mrb_value *p = ARY_PTR(a);
 
   mrb_ary_modify(mrb, a);
-  for (i = 0; i < len; ++i) {
+  for (i = 0; i < len; i++) {
     if (!mrb_nil_p(p[i])) {
       if (i != j) p[j] = p[i];
       j++;
diff --git a/mrbgems/mruby-bigint/core/bigint.c b/mrbgems/mruby-bigint/core/bigint.c
index ac93faaa2..5c757729c 100644
--- a/mrbgems/mruby-bigint/core/bigint.c
+++ b/mrbgems/mruby-bigint/core/bigint.c
@@ -730,7 +730,7 @@ mpz_get_str(mrb_state *mrb, char *s, mrb_int sz, mrb_int base, mpz_t *x)
   }
 
   /* reverse string */
-  for (char *u = ps,*v=s-1; u < v; ++u,--v) {
+  for (char *u = ps,*v=s-1; u < v; u++,v--) {
     char temp = *u;
     *u = *v;
     *v = temp;
diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
index 695c32981..02a9a08e4 100644
--- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
+++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
@@ -706,7 +706,7 @@ main(int argc, char **argv)
   if (args.rfp) fclose(args.rfp);
   mrb_free(mrb, args.argv);
   if (args.libv) {
-    for (i = 0; i < args.libc; ++i) {
+    for (i = 0; i < args.libc; i++) {
       mrb_free(mrb, args.libv[i]);
     }
     mrb_free(mrb, args.libv);
diff --git a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
index 13003d693..3faaaccd3 100644
--- a/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
+++ b/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c
@@ -104,7 +104,7 @@ options_opt(struct options *opts)
     if (opts->opt[1] == '-') {
       /* `--` */
       if (!opts->opt[2]) {
-        ++opts->argv, --opts->argc;
+        opts->argv++, opts->argc--;
         return NULL;
       }
       /* long option */
@@ -114,7 +114,7 @@ options_opt(struct options *opts)
     }
     else {
       /* short option */
-      ++opts->opt;
+      opts->opt++;
       goto short_opt;
     }
   }
diff --git a/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c b/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c
index ff39dd357..8615afcef 100644
--- a/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c
+++ b/mrbgems/mruby-bin-strip/tools/mruby-strip/mruby-strip.c
@@ -35,7 +35,7 @@ parse_args(int argc, char **argv, struct strip_args *args)
   args->argv = argv;
   args->lvar = FALSE;
 
-  for (i = 1; i < argc; ++i) {
+  for (i = 1; i < argc; i++) {
     const size_t len = strlen(argv[i]);
     if (len >= 2 && argv[i][0] == '-') {
       switch (argv[i][1]) {
@@ -65,7 +65,7 @@ strip(mrb_state *mrb, struct strip_args *args)
 {
   int i;
 
-  for (i = args->argc_start; i < args->argc; ++i) {
+  for (i = args->argc_start; i < args->argc; i++) {
     char *filename;
     FILE *rfile;
     mrb_irep *irep;
diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index 37debdca0..41e269e66 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -1256,7 +1256,7 @@ search_upvar(codegen_scope *s, mrb_sym id, int *idx)
     if (*idx > 0) {
       return lv;
     }
-    lv ++;
+    lv++;
     up = up->prev;
   }
 
@@ -1278,7 +1278,7 @@ search_upvar(codegen_scope *s, mrb_sym id, int *idx)
     }
     if (MRB_PROC_SCOPE_P(u)) break;
     u = u->upper;
-    lv ++;
+    lv++;
   }
 
   if (id == MRB_OPSYM_2(s->mrb, and)) {
@@ -2083,13 +2083,13 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
         /* fall through */
       case NODE_BEGIN:
         codegen(s, tree->car, VAL);
-        ++j;
+        j++;
         break;
 
       case NODE_LITERAL_DELIM:
         if (j > 0) {
           j = 0;
-          ++i;
+          i++;
           if (sym)
             gen_intern(s);
         }
@@ -2117,7 +2117,7 @@ gen_literal_array(codegen_scope *s, node *tree, mrb_bool sym, int val)
       tree = tree->cdr;
     }
     if (j > 0) {
-      ++i;
+      i++;
       if (sym)
         gen_intern(s);
     }
@@ -4022,7 +4022,7 @@ catch_handler_new(codegen_scope *s)
 {
   size_t newsize = sizeof(struct mrb_irep_catch_handler) * (s->irep->clen + 1);
   s->catch_table = (struct mrb_irep_catch_handler*)codegen_realloc(s, (void*)s->catch_table, newsize);
-  return s->irep->clen ++;
+  return s->irep->clen++;
 }
 
 static void
@@ -4093,7 +4093,7 @@ mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
     irep->lv = NULL;
   }
   if (!irep->reps) return;
-  for (i = 0; i < irep->rlen; ++i) {
+  for (i = 0; i < irep->rlen; i++) {
     mrb_irep_remove_lv(mrb, (mrb_irep*)irep->reps[i]);
   }
 }
diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y
index e09f1fe20..bd7345d35 100644
--- a/mrbgems/mruby-compiler/core/parse.y
+++ b/mrbgems/mruby-compiler/core/parse.y
@@ -4881,8 +4881,8 @@ parse_string(parser_state *p)
         int len = toklen(p);
         if (hinfo->allow_indent) {
           while (ISSPACE(*s) && len > 0) {
-            ++s;
-            --len;
+            s++;
+            len--;
           }
         }
         if (hinfo->term_len > 0 && len-1 == hinfo->term_len && strncmp(s, hinfo->term, len-1) == 0) {
@@ -4917,7 +4917,7 @@ parse_string(parser_state *p)
       if (c == '\t')
         spaces += 8;
       else if (ISSPACE(c))
-        ++spaces;
+        spaces++;
       else
         empty = FALSE;
     }
@@ -6773,7 +6773,7 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
   p->filename_sym = sym;
   p->lineno = (p->filename_table_length > 0)? 0 : 1;
 
-  for (i = 0; i < p->filename_table_length; ++i) {
+  for (i = 0; i < p->filename_table_length; i++) {
     if (p->filename_table[i] == sym) {
       p->current_filename_index = i;
       return;
diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c
index 5705fe573..89da3db7e 100644
--- a/mrbgems/mruby-compiler/core/y.tab.c
+++ b/mrbgems/mruby-compiler/core/y.tab.c
@@ -11077,8 +11077,8 @@ parse_string(parser_state *p)
         int len = toklen(p);
         if (hinfo->allow_indent) {
           while (ISSPACE(*s) && len > 0) {
-            ++s;
-            --len;
+            s++;
+            len--;
           }
         }
         if (hinfo->term_len > 0 && len-1 == hinfo->term_len && strncmp(s, hinfo->term, len-1) == 0) {
@@ -11113,7 +11113,7 @@ parse_string(parser_state *p)
       if (c == '\t')
         spaces += 8;
       else if (ISSPACE(c))
-        ++spaces;
+        spaces++;
       else
         empty = FALSE;
     }
@@ -12969,7 +12969,7 @@ mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
   p->filename_sym = sym;
   p->lineno = (p->filename_table_length > 0)? 0 : 1;
 
-  for (i = 0; i < p->filename_table_length; ++i) {
+  for (i = 0; i < p->filename_table_length; i++) {
     if (p->filename_table[i] == sym) {
       p->current_filename_index = i;
       return;
diff --git a/mrbgems/mruby-error/src/exception.c b/mrbgems/mruby-error/src/exception.c
index ffa7d53bf..b43a3ef05 100644
--- a/mrbgems/mruby-error/src/exception.c
+++ b/mrbgems/mruby-error/src/exception.c
@@ -53,7 +53,7 @@ mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data, mrb_fun
   mrb_value result = mrb_protect_error(mrb, protect_body, &protect_data, &error);
   if (error) {
     mrb_bool error_matched = FALSE;
-    for (mrb_int i = 0; i < len; ++i) {
+    for (mrb_int i = 0; i < len; i++) {
       if (mrb_obj_is_kind_of(mrb, result, classes[i])) {
         error_matched = TRUE;
         break;
diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c
index 164bfe131..1f6f88e83 100644
--- a/mrbgems/mruby-math/src/math.c
+++ b/mrbgems/mruby-math/src/math.c
@@ -116,10 +116,10 @@ erf(double x)
   do {
     term *= xsqr/j;
     sum  -= term/(2*j+1);
-    ++j;
+    j++;
     term *= xsqr/j;
     sum  += term/(2*j+1);
-    ++j;
+    j++;
     if (sum == 0) break;
   } while (fabs(term/sum) > DBL_EPSILON);
   return two_sqrtpi*sum;
diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c
index 9999e0ef7..b5ecdc647 100644
--- a/mrbgems/mruby-pack/src/pack.c
+++ b/mrbgems/mruby-pack/src/pack.c
@@ -196,18 +196,18 @@ u32tostr(char *buf, size_t len, uint32_t n)
     return;
   }
 
-  *p -- = '\0';
-  len --;
+  *p-- = '\0';
+  len--;
 
   if (n > 0) {
     for (; len > 0 && n > 0; len --, n /= 10) {
       *p -- = '0' + (n % 10);
     }
-    p ++;
+    p++;
   }
   else if (len > 0) {
     *p = '0';
-    len --;
+    len--;
   }
 
   memmove(buf, p, bufend - p);
@@ -292,18 +292,18 @@ u64tostr(char *buf, size_t len, uint64_t n)
     return;
   }
 
-  *p -- = '\0';
-  len --;
+  *p-- = '\0';
+  len--;
 
   if (n > 0) {
-    for (; len > 0 && n > 0; len --, n /= 10) {
-      *p -- = '0' + (n % 10);
+    for (; len > 0 && n > 0; len--, n /= 10) {
+      *p-- = '0' + (n % 10);
     }
-    p ++;
+    p++;
   }
   else if (len > 0) {
     *p = '0';
-    len --;
+    len--;
   }
 
   memmove(buf, p, bufend - p);
@@ -322,8 +322,8 @@ i64tostr(char *buf, size_t len, int64_t n)
   }
 
   if (n < 0) {
-    *buf ++ = '-';
-    len --;
+    *buf++ = '-';
+    len--;
     n = -n;
   }
 
@@ -434,13 +434,13 @@ pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned i
       memcpy(RSTRING_PTR(str) + sidx, buffer, 8);
     }
     else {
-      for (i = 0; i < 8; ++i) {
+      for (i = 0; i < 8; i++) {
         RSTRING_PTR(str)[sidx + i] = buffer[8 - i - 1];
       }
     }
   } else {
     if (littleendian) {
-      for (i = 0; i < 8; ++i) {
+      for (i = 0; i < 8; i++) {
         RSTRING_PTR(str)[sidx + i] = buffer[8 - i - 1];
       }
     }
@@ -464,13 +464,13 @@ unpack_double(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value a
       memcpy(buffer, src, 8);
     }
     else {
-      for (i = 0; i < 8; ++i) {
+      for (i = 0; i < 8; i++) {
         buffer[8 - i - 1] = src[i];
       }
     }
   } else {
     if (littleendian) {
-      for (i = 0; i < 8; ++i) {
+      for (i = 0; i < 8; i++) {
         buffer[8 - i - 1] = src[i];
       }
     }
@@ -497,13 +497,13 @@ pack_float(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned in
       memcpy(RSTRING_PTR(str) + sidx, buffer, 4);
     }
     else {
-      for (i = 0; i < 4; ++i) {
+      for (i = 0; i < 4; i++) {
         RSTRING_PTR(str)[sidx + i] = buffer[4 - i - 1];
       }
     }
   } else {
     if (littleendian) {
-      for (i = 0; i < 4; ++i) {
+      for (i = 0; i < 4; i++) {
         RSTRING_PTR(str)[sidx + i] = buffer[4 - i - 1];
       }
     }
@@ -527,13 +527,13 @@ unpack_float(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value ar
       memcpy(buffer, src, 4);
     }
     else {
-      for (i = 0; i < 4; ++i) {
+      for (i = 0; i < 4; i++) {
         buffer[4 - i - 1] = src[i];
       }
     }
   } else {
     if (littleendian) {
-      for (i = 0; i < 4; ++i) {
+      for (i = 0; i < 4; i++) {
         buffer[4 - i - 1] = src[i];
       }
     }
diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c
index 40b27aa20..3b13fb57c 100644
--- a/mrbgems/mruby-rational/src/rational.c
+++ b/mrbgems/mruby-rational/src/rational.c
@@ -138,7 +138,7 @@ i_gcd(mrb_int x, mrb_int y)
 
   u = (mrb_uint)x;
   v = (mrb_uint)y;
-  for (shift = 0; ((u | v) & 1) == 0; ++shift) {
+  for (shift = 0; ((u | v) & 1) == 0; shift++) {
     u >>= 1;
     v >>= 1;
   }
diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c
index 48146579a..5d8b7678c 100644
--- a/mrbgems/mruby-sprintf/src/sprintf.c
+++ b/mrbgems/mruby-sprintf/src/sprintf.c
@@ -588,8 +588,8 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm
     mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision");           \
   }
 
-  ++argc;
-  --argv;
+  argc++;
+  argv--;
   mrb_ensure_string_type(mrb, fmt);
   p = RSTRING_PTR(fmt);
   end = p + RSTRING_LEN(fmt);
@@ -605,7 +605,7 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm
     int flags = FNONE;
 
     for (t = p; t < end && *t != '%'; t++) ;
-    if (t + 1 == end) ++t;
+    if (t + 1 == end) t++;
     PUSH(p, t - p);
     if (t >= end)
       goto sprint_exit; /* end of fmt string */
@@ -1036,7 +1036,7 @@ retry:
           else if (flags & (FPLUS|FSPACE))
             sign = (flags & FPLUS) ? '+' : ' ';
           if (sign)
-            ++need;
+            need++;
           if ((flags & FWIDTH) && need < width)
             need = width;
 
diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c
index 3c3b1048d..64e9c2950 100644
--- a/mrbgems/mruby-string-ext/src/string.c
+++ b/mrbgems/mruby-string-ext/src/string.c
@@ -27,8 +27,8 @@ str_casecmp_p(const char *s1, mrb_int len1, const char *s2, mrb_int len2)
   e2 = s2 + len2;
   while (s1 < e1 && s2 < e2) {
     if (*s1 != *s2 && TOUPPER(*s1) != TOUPPER(*s2)) return FALSE;
-    ++s1;
-    ++s2;
+    s1++;
+    s2++;
   }
   return TRUE;
 }
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index fc93d8a92..7a8701e4c 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -618,7 +618,7 @@ mrb_struct_to_h(mrb_state *mrb, mrb_value self)
   members = struct_members(mrb, self);
   ret = mrb_hash_new_capa(mrb, RARRAY_LEN(members));
 
-  for (i = 0; i < RARRAY_LEN(members); ++i) {
+  for (i = 0; i < RARRAY_LEN(members); i++) {
     mrb_hash_set(mrb, ret, RARRAY_PTR(members)[i], RSTRUCT_PTR(self)[i]);
   }
 
diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c
index 21e272536..fdb7c974a 100644
--- a/mrbgems/mruby-test/driver.c
+++ b/mrbgems/mruby-test/driver.c
@@ -55,7 +55,7 @@ t_print(mrb_state *mrb, mrb_value self)
   mrb_int i;
 
   mrb_get_args(mrb, "*!", &argv, &argc);
-  for (i = 0; i < argc; ++i) {
+  for (i = 0; i < argc; i++) {
     mrb_value s = mrb_obj_as_string(mrb, argv[i]);
     fwrite(RSTRING_PTR(s), RSTRING_LEN(s), 1, stdout);
   }
@@ -76,7 +76,7 @@ str_match_bracket(const char *p, const char *pat_end,
   if (p == pat_end) return NULL;
   if (*p == '!' || *p == '^') {
     negated = TRUE;
-    ++p;
+    p++;
   }
 
   while (*p != ']') {
@@ -109,7 +109,7 @@ str_match_no_brace_p(const char *pat, mrb_int pat_len,
     if (p == pat_end) return s == str_end;
     switch (*p) {
       case '*':
-        do { ++p; } while (p != pat_end && *p == '*');
+        do { p++; } while (p != pat_end && *p == '*');
         if (UNESCAPE(p, pat_end) == pat_end) return TRUE;
         if (s == str_end) return FALSE;
         p_tmp = p;
@@ -117,15 +117,15 @@ str_match_no_brace_p(const char *pat, mrb_int pat_len,
         continue;
       case '?':
         if (s == str_end) return FALSE;
-        ++p;
-        ++s;
+        p++;
+        s++;
         continue;
       case '[': {
         const char *t;
         if (s == str_end) return FALSE;
         if ((t = str_match_bracket(p+1, pat_end, s, str_end))) {
           p = t;
-          ++s;
+          s++;
           continue;
         }
         goto L_failed;
@@ -164,7 +164,7 @@ str_match_p(mrb_state *mrb,
   int nest = 0;
   mrb_bool ret = FALSE;
 
-  for (; p != pat_end; ++p) {
+  for (; p != pat_end; p++) {
     if (*p == '{' && nest++ == 0) lbrace = p;
     else if (*p == '}' && lbrace && --nest == 0) { rbrace = p; break; }
     else if (*p == '\\' && ++p == pat_end) break;
@@ -180,9 +180,9 @@ str_match_p(mrb_state *mrb,
     while (p < rbrace) {
       char *orig_ex_p = ex_p;
       const char *t = ++p;
-      for (nest = 0; p < rbrace && !(*p == ',' && nest == 0); ++p) {
-        if (*p == '{') ++nest;
-        else if (*p == '}') --nest;
+      for (nest = 0; p < rbrace && !(*p == ',' && nest == 0); p++) {
+        if (*p == '{') nest++;
+        else if (*p == '}') nest--;
         else if (*p == '\\' && ++p == rbrace) break;
       }
       COPY_AND_INC(ex_p, t, p-t);
@@ -271,7 +271,7 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
   if (mrb_array_p(res_src)) {
     mrb_int i;
     mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$asserts"));
-    for (i = 0; i < RARRAY_LEN(res_src); ++i) {
+    for (i = 0; i < RARRAY_LEN(res_src); i++) {
       mrb_value val_src = RARRAY_PTR(res_src)[i];
       mrb_ary_push(mrb_dst, res_dst, mrb_str_new(mrb_dst, RSTRING_PTR(val_src), RSTRING_LEN(val_src)));
     }
diff --git a/src/array.c b/src/array.c
index 7c56c8854..a51a285d1 100644
--- a/src/array.c
+++ b/src/array.c
@@ -602,7 +602,7 @@ mrb_ary_shift(mrb_state *mrb, mrb_value self)
     val = *ptr;
     while (--size) {
       *ptr = *(ptr+1);
-      ++ptr;
+      ptr++;
     }
     ARY_SET_LEN(a, len-1);
   }
@@ -646,7 +646,7 @@ mrb_ary_shift_m(mrb_state *mrb, mrb_value self)
 
     while (size--) {
       *ptr = *(ptr+n);
-      ++ptr;
+      ptr++;
     }
     ARY_SET_LEN(a, len-n);
   }
@@ -1074,7 +1074,7 @@ mrb_ary_delete_at(mrb_state *mrb, mrb_value self)
   len = alen - index;
   while (--len) {
     *ptr = *(ptr+1);
-    ++ptr;
+    ptr++;
   }
   ARY_SET_LEN(a, alen-1);
 
diff --git a/src/cdump.c b/src/cdump.c
index 79216eab0..a054e650a 100644
--- a/src/cdump.c
+++ b/src/cdump.c
@@ -172,7 +172,7 @@ sym_operator_name(const char *sym_name, mrb_int len)
     }
     if (0 < cmp) {
       start = ++idx;
-      --table_size;
+      table_size--;
     }
   }
   return NULL;
diff --git a/src/fmt_fp.c b/src/fmt_fp.c
index ff106c014..7c5b01a99 100644
--- a/src/fmt_fp.c
+++ b/src/fmt_fp.c
@@ -275,7 +275,7 @@ mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, ch
   }
 
   // Print the digits of the mantissa
-  for (int i = 0; i < num_digits; ++i, --dec) {
+  for (int i = 0; i < num_digits; i++,dec--) {
     int8_t d = (int8_t)((int)f)%10;
     *s++ = '0' + d;
     if (dec == 0 && (prec > 0 || alt_form)) {
diff --git a/src/hash.c b/src/hash.c
index aac9ab570..40cfacf67 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -170,7 +170,7 @@ DEFINE_SWITCHER(ht, HT)
 
 #define ea_each_used(ea, n_used, entry_var, code) do {                        \
   hash_entry *entry_var = ea, *ea_end__ = entry_var + (n_used);               \
-  for (; entry_var < ea_end__; ++entry_var) {                                 \
+  for (; entry_var < ea_end__; entry_var++) {                                 \
     code;                                                                     \
   }                                                                           \
 } while (0)
@@ -178,7 +178,7 @@ DEFINE_SWITCHER(ht, HT)
 #define ea_each(ea, size, entry_var, code) do {                               \
   hash_entry *entry_var = ea;                                                 \
   uint32_t size__ = size;                                                     \
-  for (; 0 < size__; ++entry_var) {                                           \
+  for (; 0 < size__; entry_var++) {                                           \
     if (entry_deleted_p(entry_var)) continue;                                 \
     --size__;                                                                 \
     code;                                                                     \
@@ -310,7 +310,7 @@ next_power2(uint32_t v)
   v |= v >> 4;
   v |= v >> 8;
   v |= v >> 16;
-  ++v;
+  v++;
   return v;
 #endif
 }
@@ -426,7 +426,7 @@ ea_compress(hash_entry *ea, uint32_t n_used)
   ea_each_used(ea, n_used, r_entry, {
     if (entry_deleted_p(r_entry)) continue;
     if (r_entry != w_entry) *w_entry = *r_entry;
-    ++w_entry;
+    w_entry++;
   });
 }
 
@@ -592,7 +592,7 @@ ar_rehash(mrb_state *mrb, struct RHash *h)
         ea_set(ea, w_size, r_entry->key, r_entry->val);
         entry_delete(r_entry);
       }
-      ++w_size;
+      w_size++;
     }
   });
   mrb_assert(size == w_size);
diff --git a/src/load.c b/src/load.c
index 1916c6c9d..cfc9a5e21 100644
--- a/src/load.c
+++ b/src/load.c
@@ -326,7 +326,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_
   if (bin > end) return MRB_DUMP_GENERAL_FAILURE;
   debug->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*));
 
-  for (f_idx = 0; f_idx < debug->flen; ++f_idx) {
+  for (f_idx = 0; f_idx < debug->flen; f_idx++) {
     mrb_irep_debug_info_file *file;
     uint16_t filename_idx;
 
@@ -353,7 +353,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_
 
         if (bin + l > end) return MRB_DUMP_GENERAL_FAILURE;
         uint16_t *ary = (uint16_t *)mrb_malloc(mrb, l);
-        for (l = 0; l < file->line_entry_count; ++l) {
+        for (l = 0; l < file->line_entry_count; l++) {
           ary[l] = bin_to_uint16(bin);
           bin += sizeof(uint16_t);
         }
@@ -366,7 +366,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, const uint8_t *end, mrb_
 
         if (bin + c*n > end) return MRB_DUMP_GENERAL_FAILURE;
         mrb_irep_debug_info_line *flat_map = (mrb_irep_debug_info_line*)mrb_calloc(mrb, c, n);
-        for (size_t l = 0; l < file->line_entry_count; ++l) {
+        for (size_t l = 0; l < file->line_entry_count; l++) {
           flat_map[l].start_pos = bin_to_uint32(bin);
           bin += sizeof(uint32_t);
           flat_map[l].line = bin_to_uint16(bin);
@@ -435,7 +435,7 @@ read_section_debug(mrb_state *mrb, const uint8_t *start, size_t size, mrb_irep *
   if (bin > end) return MRB_DUMP_GENERAL_FAILURE;
   filenames_obj = mrb_str_new(mrb, NULL, sizeof(mrb_sym) * (size_t)filenames_len);
   filenames = (mrb_sym*)RSTRING_PTR(filenames_obj);
-  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 (bin + f_len > end) {
@@ -477,7 +477,7 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec
   if (irep->nlocals == 0) return MRB_DUMP_GENERAL_FAILURE;
   irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (irep->nlocals - 1));
 
-  for (i = 0; i + 1 < irep->nlocals; ++i) {
+  for (i = 0; i + 1 < irep->nlocals; i++) {
     uint16_t const sym_idx = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
     if (sym_idx == RITE_LV_NULL_MARK) {
@@ -491,7 +491,7 @@ read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *rec
     }
   }
 
-  for (i = 0; i < irep->rlen; ++i) {
+  for (i = 0; i < irep->rlen; i++) {
     size_t len;
     int ret;
 
@@ -532,7 +532,7 @@ read_section_lv(mrb_state *mrb, const uint8_t *start, size_t size, mrb_irep *ire
   if (bin > end) return MRB_DUMP_READ_FAULT;
   syms_obj = mrb_str_new(mrb, NULL, sizeof(mrb_sym) * (size_t)syms_len);
   syms = (mrb_sym*)RSTRING_PTR(syms_obj);
-  for (i = 0; i < syms_len; ++i) {
+  for (i = 0; i < syms_len; i++) {
     uint16_t const str_len = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
     if (bin > end) return MRB_DUMP_READ_FAULT;
diff --git a/src/proc.c b/src/proc.c
index bbc4a2b14..c27e6ea7a 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -154,12 +154,12 @@ mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const
   MRB_ENV_SET_LEN(e, argc);
 
   if (argv) {
-    for (i = 0; i < argc; ++i) {
+    for (i = 0; i < argc; i++) {
       e->stack[i] = argv[i];
     }
   }
   else {
-    for (i = 0; i < argc; ++i) {
+    for (i = 0; i < argc; i++) {
       SET_NIL_VALUE(e->stack[i]);
     }
   }
@@ -334,7 +334,7 @@ mrb_proc_local_variables(mrb_state *mrb, const struct RProc *proc)
     if (MRB_PROC_CFUNC_P(proc)) break;
     irep = proc->body.irep;
     if (irep->lv) {
-      for (i = 0; i + 1 < irep->nlocals; ++i) {
+      for (i = 0; i + 1 < irep->nlocals; i++) {
         if (irep->lv[i]) {
           mrb_sym sym = irep->lv[i];
           const char *name = mrb_sym_name(mrb, sym);
diff --git a/src/range.c b/src/range.c
index 34ae7e451..a81bcd428 100644
--- a/src/range.c
+++ b/src/range.c
@@ -407,17 +407,17 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con
   mrb_value result;
   result = mrb_ary_new(mrb);
 
-  for (i = 0; i < argc; ++i) {
+  for (i = 0; i < argc; i++) {
     if (mrb_integer_p(argv[i])) {
       mrb_ary_push(mrb, result, func(mrb, obj, mrb_integer(argv[i])));
     }
     else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == MRB_RANGE_OK) {
       mrb_int const end = olen < beg + len ? olen : beg + len;
-      for (j = beg; j < end; ++j) {
+      for (j = beg; j < end; j++) {
         mrb_ary_push(mrb, result, func(mrb, obj, j));
       }
 
-      for (; j < beg + len; ++j) {
+      for (; j < beg + len; j++) {
         mrb_ary_push(mrb, result, mrb_nil_value());
       }
     }
diff --git a/src/string.c b/src/string.c
index 1b5aecff2..7073fb679 100644
--- a/src/string.c
+++ b/src/string.c
@@ -343,7 +343,7 @@ bytes2chars(char *p, mrb_int len, mrb_int bi)
   const char *pivot = p + bi;
   mrb_int i;
 
-  for (i = 0; p < pivot; i ++) {
+  for (i = 0; p < pivot; i++) {
     p += mrb_utf8len(p, e);
   }
   if (p != pivot) return -1;
@@ -383,10 +383,10 @@ str_index_str_by_char_search(mrb_state *mrb, const char *p, const char *pend, co
   {
     mrb_int i;
 
-    for (i = 0; i < 1 << CHAR_BIT; i ++) {
+    for (i = 0; i < 1 << CHAR_BIT; i++) {
       qstable[i] = slen;
     }
-    for (i = 0; i < slen; i ++) {
+    for (i = 0; i < slen; i++) {
       qstable[(unsigned char)s[i]] = slen - (i + 1);
     }
   }
@@ -404,7 +404,7 @@ str_index_str_by_char_search(mrb_state *mrb, const char *p, const char *pend, co
 
     do {
       p += mrb_utf8len(p, pend);
-      off ++;
+      off++;
     } while (p < pivot);
   }
 
@@ -469,9 +469,9 @@ mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mr
     ptrdiff_t qstable[256];
 
     /* Preprocessing */
-    for (i = 0; i < 256; ++i)
+    for (i = 0; i < 256; i++)
       qstable[i] = m + 1;
-    for (; x < xe; ++x)
+    for (; x < xe; x++)
       qstable[*x] = xe - x;
     /* Searching */
     for (; y + m <= ys + n; y += *(qstable + y[m])) {
@@ -2190,7 +2190,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
         mrb_gc_arena_restore(mrb, ai);
         skip = TRUE;
         beg = idx;
-        if (lim_p) ++i;
+        if (lim_p) i++;
       }
       else {
         end = idx;