[svn:parrot] r46192 - in trunk/src: . call gc interp io packfile pmc runcore string string/charset string/encoding

jimmy at svn.parrot.org jimmy at svn.parrot.org
Fri Apr 30 08:27:18 UTC 2010


Author: jimmy
Date: Fri Apr 30 08:27:15 2010
New Revision: 46192
URL: https://trac.parrot.org/parrot/changeset/46192

Log:
manual optimization for old compiler

Modified:
   trunk/src/call/args.c
   trunk/src/call/context.c
   trunk/src/datatypes.c
   trunk/src/debug.c
   trunk/src/embed.c
   trunk/src/exceptions.c
   trunk/src/frame_builder.c
   trunk/src/gc/alloc_resources.c
   trunk/src/gc/gc_ms.c
   trunk/src/gc/malloc.c
   trunk/src/gc/malloc_trace.c
   trunk/src/gc/mark_sweep.c
   trunk/src/gc/system.c
   trunk/src/hash.c
   trunk/src/interp/inter_misc.c
   trunk/src/io/buffer.c
   trunk/src/io/core.c
   trunk/src/longopt.c
   trunk/src/main.c
   trunk/src/multidispatch.c
   trunk/src/nci_test.c
   trunk/src/oo.c
   trunk/src/packdump.c
   trunk/src/packfile.c
   trunk/src/packfile/pf_items.c
   trunk/src/packout.c
   trunk/src/pbc_dump.c
   trunk/src/pbc_merge.c
   trunk/src/pmc/callcontext.pmc
   trunk/src/pmc/class.pmc
   trunk/src/pmc/codestring.pmc
   trunk/src/pmc/complex.pmc
   trunk/src/pmc/env.pmc
   trunk/src/pmc/eval.pmc
   trunk/src/pmc/exceptionhandler.pmc
   trunk/src/pmc/exporter.pmc
   trunk/src/pmc/fixedbooleanarray.pmc
   trunk/src/pmc/fixedpmcarray.pmc
   trunk/src/pmc/fixedstringarray.pmc
   trunk/src/pmc/float.pmc
   trunk/src/pmc/hashiterator.pmc
   trunk/src/pmc/imageio.pmc
   trunk/src/pmc/namespace.pmc
   trunk/src/pmc/nci.pmc
   trunk/src/pmc/orderedhashiterator.pmc
   trunk/src/pmc/pmcproxy.pmc
   trunk/src/pmc/resizablepmcarray.pmc
   trunk/src/pmc/resizablestringarray.pmc
   trunk/src/pmc/role.pmc
   trunk/src/pmc/scheduler.pmc
   trunk/src/pmc/string.pmc
   trunk/src/pmc/sub.pmc
   trunk/src/pmc_freeze.c
   trunk/src/runcore/cores.c
   trunk/src/runcore/profiling.c
   trunk/src/runcore/trace.c
   trunk/src/scheduler.c
   trunk/src/spf_render.c
   trunk/src/spf_vtable.c
   trunk/src/string/api.c
   trunk/src/string/charset.c
   trunk/src/string/charset/ascii.c
   trunk/src/string/charset/iso-8859-1.c
   trunk/src/string/encoding.c
   trunk/src/string/encoding/fixed_8.c
   trunk/src/string/encoding/ucs2.c
   trunk/src/string/encoding/utf16.c
   trunk/src/string/encoding/utf8.c
   trunk/src/sub.c
   trunk/src/thread.c
   trunk/src/utils.c
   trunk/src/vtables.c

Modified: trunk/src/call/args.c
==============================================================================
--- trunk/src/call/args.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/call/args.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -337,7 +337,7 @@
     GETATTR_FixedIntegerArray_size(interp, raw_sig, arg_count);
     GETATTR_FixedIntegerArray_int_array(interp, raw_sig, int_array);
 
-    for (; arg_index < arg_count; arg_index++) {
+    for (; arg_index < arg_count; ++arg_index) {
         const INTVAL arg_flags = int_array[arg_index];
         const INTVAL constant  = PARROT_ARG_CONSTANT_ISSET(arg_flags);
         const INTVAL raw_index = raw_args[arg_index + 2];
@@ -369,7 +369,7 @@
                     string_value = CTX_REG_STR(ctx, raw_index);
 
                 if (arg_flags & PARROT_ARG_NAME) {
-                    arg_index++;
+                    ++arg_index;
                     if (!PMC_IS_NULL(call_object)
                          && VTABLE_exists_keyed_str(interp, call_object, string_value)) {
                         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
@@ -494,7 +494,7 @@
     if (VTABLE_does(interp, aggregate, CONST_STRING(interp, "array"))) {
         const INTVAL elements = VTABLE_elements(interp, aggregate);
         INTVAL index;
-        for (index = 0; index < elements; index++) {
+        for (index = 0; index < elements; ++index) {
             VTABLE_push_pmc(interp, call_object,
                     VTABLE_get_pmc_keyed_int(interp, aggregate, index));
         }
@@ -507,7 +507,7 @@
         SETATTR_Key_next_key(interp, key, (PMC *)INITBucketIndex);
 
         /* Low-level hash iteration. */
-        for (index = 0; index < elements; index++) {
+        for (index = 0; index < elements; ++index) {
             if (!PMC_IS_NULL(key)) {
                 STRING * const name = (STRING *)parrot_hash_get_idx(interp,
                                 (Hash *)VTABLE_get_pointer(interp, aggregate), key);
@@ -610,7 +610,7 @@
                 PMC * const pmc_arg = va_arg(*args, PMC *);
                 if (type_lookahead == 'f') {
                     dissect_aggregate_arg(interp, call_object, pmc_arg);
-                    i++; /* skip 'f' */
+                    ++i; /* skip 'f' */
                 }
                 else if (type_lookahead == 'i') {
                     if (i)
@@ -619,7 +619,7 @@
                             "Dispatch: only the first argument can be an invocant");
                     else {
                         VTABLE_push_pmc(interp, call_object, pmc_arg);
-                        i++; /* skip 'i' */
+                        ++i; /* skip 'i' */
                         Parrot_pcc_set_object(interp, call_object, pmc_arg);
                     }
                 }
@@ -701,7 +701,7 @@
                 PMC * const pmc_arg = va_arg(args, PMC *);
                 if (type_lookahead == 'f') {
                      dissect_aggregate_arg(interp, call_object, pmc_arg);
-                    i++; /* skip 'f' */
+                     ++i; /* skip 'f' */
                 }
                 else {
                     VTABLE_push_pmc(interp, call_object, PMC_IS_NULL(pmc_arg)
@@ -713,7 +713,7 @@
                                 EXCEPTION_INVALID_OPERATION,
                                 "Dispatch: only the first argument "
                                 "can be an invocant");
-                        i++;           /* skip 'i' */
+                        ++i;           /* skip 'i' */
                         append_pi = 0; /* Don't prepend Pi to signature */
                     }
                 }
@@ -848,13 +848,13 @@
             collect_positional = Parrot_pmc_new(interp,
                 Parrot_get_ctx_HLL_type(interp, enum_class_ResizablePMCArray));
 
-            for (; arg_index < positional_args; arg_index++) {
+            for (; arg_index < positional_args; ++arg_index) {
                 VTABLE_push_pmc(interp, collect_positional,
                     VTABLE_get_pmc_keyed_int(interp, call_object, arg_index));
             }
 
             *accessor->pmc(interp, arg_info, param_index) = collect_positional;
-            param_index++;
+            ++param_index;
             break; /* Terminate the positional arg loop. */
         }
 
@@ -872,8 +872,8 @@
                    ?  accessor->string_constant(interp, arg_info, param_index)
                    : *accessor->string(interp, arg_info, param_index);
 
-                named_count++;
-                param_index++;
+                ++named_count;
+                ++param_index;
                 if (param_index >= param_count)
                     continue;
 
@@ -922,7 +922,7 @@
                     const int next_param_flags = raw_params[param_index + 1];
 
                     if (next_param_flags & PARROT_ARG_OPT_FLAG) {
-                        param_index++;
+                        ++param_index;
                         *accessor->intval(interp, arg_info, param_index) = 1;
                     }
                 }
@@ -945,7 +945,7 @@
                 const INTVAL next_param_flags = raw_params[param_index + 1];
 
                 if (next_param_flags & PARROT_ARG_OPT_FLAG) {
-                    param_index++;
+                    ++param_index;
                     *accessor->intval(interp, arg_info, param_index) = 0;
                 }
             }
@@ -966,8 +966,8 @@
         }
 
         /* Go on to next argument and parameter. */
-        arg_index++;
-        param_index++;
+        ++arg_index;
+        ++param_index;
     }
 
     /* Now iterate over the named arguments and parameters. */
@@ -1017,7 +1017,7 @@
                 INTVAL named_arg_index;
 
                 /* Named argument iteration. */
-                for (named_arg_index = 0; named_arg_index < named_arg_count; named_arg_index++) {
+                for (named_arg_index = 0; named_arg_index < named_arg_count; ++named_arg_index) {
                     STRING * const name = VTABLE_get_string_keyed_int(interp,
                             named_arg_list, named_arg_index);
 
@@ -1030,7 +1030,7 @@
                         if (PMC_IS_NULL(named_used_list))
                             named_used_list = Parrot_pmc_new(interp, enum_class_Hash);
                         VTABLE_set_integer_keyed_str(interp, named_used_list, name, 1);
-                        named_count++;
+                        ++named_count;
                     }
                 }
             }
@@ -1051,8 +1051,7 @@
 
         if (!STRING_IS_NULL(param_name)) {
             /* The next parameter is the actual value. */
-            param_index++;
-            if (param_index >= param_count)
+            if (++param_index >= param_count)
                 continue;
 
             param_flags = raw_params[param_index];
@@ -1064,7 +1063,7 @@
                 if (PMC_IS_NULL(named_used_list))
                     named_used_list = Parrot_pmc_new(interp, enum_class_Hash);
                 VTABLE_set_integer_keyed_str(interp, named_used_list, param_name, 1);
-                named_count++;
+                ++named_count;
 
                 /* Fill the named parameter. */
                 switch (PARROT_ARG_TYPE_MASK_MASK(param_flags)) {
@@ -1096,7 +1095,7 @@
                         const INTVAL next_param_flags = raw_params[param_index + 1];
 
                         if (next_param_flags & PARROT_ARG_OPT_FLAG) {
-                            param_index++;
+                            ++param_index;
                             *accessor->intval(interp, arg_info, param_index) = 1;
                         }
                     }
@@ -1112,7 +1111,7 @@
                     const INTVAL next_param_flags = raw_params[param_index + 1];
 
                     if (next_param_flags & PARROT_ARG_OPT_FLAG) {
-                        param_index++;
+                        ++param_index;
                         *accessor->intval(interp, arg_info, param_index) = 0;
                     }
                 }
@@ -1129,7 +1128,7 @@
             }
         }
 
-        param_index++;
+        ++param_index;
     }
 
     /* Double check that all named arguments were assigned to parameters. */
@@ -1166,8 +1165,8 @@
                 INTVAL named_arg_index;
 
                 /* Named argument iteration. */
-                for (named_arg_index = 0; named_arg_index < named_arg_count; named_arg_index++) {
-                    STRING *name = VTABLE_get_string_keyed_int(interp,
+                for (named_arg_index = 0; named_arg_index < named_arg_count; ++named_arg_index) {
+                    STRING * const name = VTABLE_get_string_keyed_int(interp,
                             named_arg_list, named_arg_index);
 
                     if (!VTABLE_exists_keyed_str(interp, named_used_list, name)) {
@@ -1360,7 +1359,7 @@
     const char *cur;
     *arg_sig = signature;
 
-    for (cur = signature; *cur != '\0'; cur++) {
+    for (cur = signature; *cur != '\0'; ++cur) {
         if (*cur == '-') {
             *return_sig = cur + 2;
             return;
@@ -1397,7 +1396,7 @@
         *arg_flags = Parrot_pmc_new(interp, enum_class_ResizableIntegerArray);
     current_array = *arg_flags;
 
-    for (x = signature; *x != '\0'; x++) {
+    for (x = signature; *x != '\0'; ++x) {
 
         /* detect -> separator */
         if (*x == '-')
@@ -1413,10 +1412,10 @@
             }
 
             switch (*x) {
-                case 'I': flags = PARROT_ARG_INTVAL;   set++; break;
-                case 'N': flags = PARROT_ARG_FLOATVAL; set++; break;
-                case 'S': flags = PARROT_ARG_STRING;   set++; break;
-                case 'P': flags = PARROT_ARG_PMC;      set++; break;
+                case 'I': flags = PARROT_ARG_INTVAL;   ++set; break;
+                case 'N': flags = PARROT_ARG_FLOATVAL; ++set; break;
+                case 'S': flags = PARROT_ARG_STRING;   ++set; break;
+                case 'P': flags = PARROT_ARG_PMC;      ++set; break;
                 default:
                     Parrot_ex_throw_from_c_args(interp, NULL,
                         EXCEPTION_INVALID_OPERATION,

Modified: trunk/src/call/context.c
==============================================================================
--- trunk/src/call/context.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/call/context.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -263,21 +263,21 @@
      * if the architecture has 0x := NULL and 0.0 we could memset too
      */
 
-    for (i = 0; i < ctx->n_regs_used[REGNO_PMC]; i++) {
+    for (i = 0; i < ctx->n_regs_used[REGNO_PMC]; ++i) {
         ctx->bp_ps.regs_p[-1L - i] = PMCNULL;
     }
 
-    for (i = 0; i < ctx->n_regs_used[REGNO_STR]; i++) {
+    for (i = 0; i < ctx->n_regs_used[REGNO_STR]; ++i) {
         ctx->bp_ps.regs_s[i] = STRINGNULL;
     }
 
     if (Interp_debug_TEST(interp, PARROT_REG_DEBUG_FLAG)) {
         /* depending on -D40, set int and num to identifiable garbage values */
-        for (i = 0; i < ctx->n_regs_used[REGNO_INT]; i++) {
+        for (i = 0; i < ctx->n_regs_used[REGNO_INT]; ++i) {
             ctx->bp.regs_i[i] = -999;
         }
 
-        for (i = 0; i < ctx->n_regs_used[REGNO_NUM]; i++) {
+        for (i = 0; i < ctx->n_regs_used[REGNO_NUM]; ++i) {
             ctx->bp.regs_n[-1L - i] = -99.9;
         }
     }

Modified: trunk/src/datatypes.c
==============================================================================
--- trunk/src/datatypes.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/datatypes.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -44,7 +44,7 @@
     char * const type = Parrot_str_to_cstring(interp, type_name);
     int i;
 
-    for (i = enum_first_type; i < enum_last_type; i++) {
+    for (i = enum_first_type; i < enum_last_type; ++i) {
         if (STREQ(data_types[i - enum_first_type].name, type)) {
             Parrot_str_free_cstring(type);
             return i;

Modified: trunk/src/debug.c
==============================================================================
--- trunk/src/debug.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/debug.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -1366,7 +1366,7 @@
     if (*(command + 1) == '=')
         command += 2;
     else
-        command++;
+        ++command;
 
     command = skip_whitespace(command);
 
@@ -1425,7 +1425,7 @@
             condition->type               |= PDB_cond_const;
         }
         else if (condition->type & PDB_cond_str) {
-            for (i = 1; ((command[i] != '"') && (i < DEBUG_CMD_BUFFER_LENGTH)); i++)
+            for (i = 1; ((command[i] != '"') && (i < DEBUG_CMD_BUFFER_LENGTH)); ++i)
                 str[i - 1] = command[i];
             str[i - 1] = '\0';
 #if TRACE_DEBUGGER
@@ -1513,7 +1513,7 @@
             /* Move to the line where we will set the break point */
             line = pdb->file->line;
 
-            for (i = 1; ((i < ln) && (line->next)); i++)
+            for (i = 1; ((i < ln) && (line->next)); ++i)
                 line = line->next;
 
             /* Abort if the line number provided doesn't exist */
@@ -2168,7 +2168,7 @@
 
     fill = _new = mem_gc_allocate_n_typed(interp, length * 2 + 1, char);
 
-    for (; string < end; string++) {
+    for (; string < end; ++string) {
         switch (*string) {
           case '\0':
             *(fill++) = '\\';
@@ -2232,8 +2232,8 @@
     ASSERT_ARGS(PDB_unescape)
     int l = 0;
 
-    for (; *string; string++) {
-        l++;
+    for (; *string; ++string) {
+        ++l;
 
         if (*string == '\\') {
             char *fill;
@@ -2261,7 +2261,7 @@
 
             fill = string;
 
-            for (i = 1; fill[i + 1]; i++)
+            for (i = 1; fill[i + 1]; ++i)
                 fill[i] = fill[i + 1];
 
             fill[i] = '\0';
@@ -2307,7 +2307,7 @@
     dest[size++] = ' ';
 
     /* Concat the arguments */
-    for (j = 1; j < info->op_count; j++) {
+    for (j = 1; j < info->op_count; ++j) {
         char      buf[256];
         INTVAL    i = 0;
 
@@ -2526,7 +2526,7 @@
         /* Register decoding.  It would be good to abstract this, too. */
         PARROT_OBSERVER static const char regs[] = "ISPN";
 
-        for (j = 0; j < n_values; j++) {
+        for (j = 0; j < n_values; ++j) {
             size_t idx = 0;
             const int sig_value = VTABLE_get_integer_keyed_int(interp, sig, j);
 
@@ -2812,7 +2812,7 @@
     /* Get the name of the file */
     for (j = 0; command[j] == ' '; ++j)
         continue;
-    for (i = 0; command[j]; i++, j++)
+    for (i = 0; command[j]; ++i, ++j)
         f[i] = command[j];
 
     f[i] = '\0';
@@ -2845,7 +2845,7 @@
         }
         pfile->source[pfile->size] = (char)c;
 
-        pfile->size++;
+        ++pfile->size;
 
         if (c == '\n') {
             /* If the line has an opcode move to the next one,
@@ -2910,7 +2910,7 @@
             h = 0;
         }
 
-        c++;
+        ++c;
     }
 
     return h;
@@ -2963,7 +2963,7 @@
         return;
     }
     reg_type_id = (unsigned char) toupper((unsigned char) command[0]);
-    command++;
+    ++command;
     register_num = get_ulong(&command, 0);
 
     switch (reg_type_id) {
@@ -3046,7 +3046,7 @@
 
     line = pdb->file->line;
 
-    for (i = 0; i < pdb->file->list_line && line->next; i++)
+    for (i = 0; i < pdb->file->list_line && line->next; ++i)
         line = line->next;
 
     i = 1;
@@ -3417,7 +3417,7 @@
     TRACEDEB_MSG("GDB_P");
     /* Skip leading whitespace. */
     while (isspace((unsigned char)*s))
-        s++;
+        ++s;
 
     reg_type = (unsigned char) toupper((unsigned char)*s);
 
@@ -3433,7 +3433,7 @@
         const int max_reg = Parrot_pcc_get_regs_used(interp, CURRENT_CONTEXT(interp), t);
         int n;
 
-        for (n = 0; n < max_reg; n++) {
+        for (n = 0; n < max_reg; ++n) {
             /* this must be done in two chunks because PMC's print directly. */
             Parrot_io_eprintf(interp, "\n  %c%d = ", reg_type, n);
             Parrot_io_eprintf(interp, "%Ss", GDB_print_reg(interp, t, n));

Modified: trunk/src/embed.c
==============================================================================
--- trunk/src/embed.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/embed.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -632,7 +632,7 @@
     VTABLE_set_pmc_keyed_int(interp, interp->iglobals,
             (INTVAL)IGLOBALS_ARGV_LIST, userargv);
 
-    for (i = 0; i < argc; i++) {
+    for (i = 0; i < argc; ++i) {
         /* Run through argv, adding everything to @ARGS. */
         STRING * const arg =
             string_make(interp, argv[i], strlen(argv[i]), "unicode",
@@ -703,7 +703,7 @@
      * entry point with the address at our resume_offset.
      */
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         if (ft->fixups[i].type == enum_fixup_sub) {
             const opcode_t ci      = ft->fixups[i].offset;
             PMC    * const sub_pmc = ct->constants[ci]->u.key;
@@ -997,7 +997,7 @@
                     interp->code->debugs->mappings[curr_mapping].filename;
                 Parrot_io_fprintf(interp, output, "# Current Source Filename '%Ss'\n",
                         interp->code->const_table->constants[filename_const_offset]->u.string);
-                curr_mapping++;
+                ++curr_mapping;
             }
         }
 
@@ -1022,7 +1022,7 @@
 
         Parrot_io_fprintf(interp, output, "\n");
         line = line->next;
-        op_code_seq_num++;
+        ++op_code_seq_num;
     }
     if (outfile != NULL)
         Parrot_io_close(interp, output);

Modified: trunk/src/exceptions.c
==============================================================================
--- trunk/src/exceptions.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/exceptions.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -589,7 +589,7 @@
             "Backtrace - Obtained %d stack frames (max trace depth is %d).\n",
             size, BACKTRACE_DEPTH);
 #  ifndef BACKTRACE_VERBOSE
-    for (i = 0; i < size; i++) {
+    for (i = 0; i < size; ++i) {
         Dl_info   frameInfo;
         const int found  = dladdr(array[i], &frameInfo);
 
@@ -608,7 +608,7 @@
     { /* Scope for strings */
         char ** strings = backtrace_symbols(array, size);
         if (strings) {
-            for (i = 0; i < size; i++)
+            for (i = 0; i < size; ++i)
                 fprintf(stderr, "%s\n", strings[i]);
             /* backtrace_symbols gets memory using malloc */
             free(strings);

Modified: trunk/src/frame_builder.c
==============================================================================
--- trunk/src/frame_builder.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/frame_builder.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -259,7 +259,7 @@
     while (*sig) {
         switch (*sig) {
           case 't':
-            (*strings)++;
+            ++(*strings);
             stack_size +=4;
             break;
           case 'd':
@@ -269,7 +269,7 @@
             stack_size +=4;
             break;
         }
-        sig++;
+        ++sig;
     }
     return stack_size;
 
@@ -461,8 +461,8 @@
             return NULL;
         }
         args_offset +=4;
-        arg_count++;
-        sig++;
+        ++arg_count;
+        ++sig;
     }
 
     /* prepare to call VTABLE_get_pointer, set up args */
@@ -608,7 +608,7 @@
 
     /* free temporary strings */
     strings_offset = st_offset + ST_SIZE_OF;
-    for (i=0; i<string_buffer_count; i++) {
+    for (i=0; i<string_buffer_count; ++i) {
         emitm_movl_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, strings_offset);
         emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 0);
         emitm_call_cfunc(pc, Parrot_str_free_cstring);

Modified: trunk/src/gc/alloc_resources.c
==============================================================================
--- trunk/src/gc/alloc_resources.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/gc/alloc_resources.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -347,7 +347,7 @@
              */
             alloc_new_block(mem_pools, size, pool, "compact failed");
 
-            mem_pools->mem_allocs_since_last_collect++;
+            ++mem_pools->mem_allocs_since_last_collect;
 
             if (pool->top_block->free < size) {
                 fprintf(stderr, "out of mem\n");
@@ -459,7 +459,7 @@
     /* We're collecting */
     mem_pools->mem_allocs_since_last_collect    = 0;
     mem_pools->header_allocs_since_last_collect = 0;
-    mem_pools->gc_collect_runs++;
+    ++mem_pools->gc_collect_runs;
 
     /* Snag a block big enough for everything */
     total_size = pad_pool_size(pool);
@@ -920,7 +920,7 @@
     check_fixed_size_obj_pool(mem_pools->string_header_pool);
     check_fixed_size_obj_pool(mem_pools->constant_string_header_pool);
 
-    for (i = 0; i < mem_pools->num_sized; i++) {
+    for (i = 0; i < mem_pools->num_sized; ++i) {
         const Fixed_Size_Pool * const pool = mem_pools->sized_header_pools[i];
         if (pool != NULL && pool != mem_pools->string_header_pool)
             check_fixed_size_obj_pool(pool);
@@ -1128,16 +1128,16 @@
     header_pools_iterate_callback(interp, mem_pools, POOL_PMC | POOL_CONST, NULL,
             sweep_cb_pmc);
 
-    for (pass = start; pass <= 2; pass++) {
+    /* for (pass = start; pass <= 2; ++pass) { */ /* XXX it's unsed loop */
         header_pools_iterate_callback(interp, mem_pools, POOL_BUFFER | POOL_CONST,
-                (void *)pass, sweep_cb_buf);
-    }
+                (void *)start, sweep_cb_buf);
+    /* } */
 
     mem_internal_free(mem_pools->sized_header_pools);
 
     if (mem_pools->attrib_pools) {
         unsigned int i;
-        for (i = 0; i < mem_pools->num_attribs; i++) {
+        for (i = 0; i < mem_pools->num_attribs; ++i) {
             PMC_Attribute_Pool  *pool  = mem_pools->attrib_pools[i];
             PMC_Attribute_Arena *arena;
 
@@ -1431,7 +1431,7 @@
         PMC   *p = (PMC *)((char*)cur_arena->start_objects);
         size_t i;
 
-        for (i = 0; i < cur_arena->used; i++) {
+        for (i = 0; i < cur_arena->used; ++i) {
             if (!PObj_on_free_list_TEST(p) && PObj_is_PMC_TEST(p)) {
                 if (PObj_is_PMC_shared_TEST(p))
                     PMC_sync(p)->owner = dest_interp;

Modified: trunk/src/gc/gc_ms.c
==============================================================================
--- trunk/src/gc/gc_ms.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/gc/gc_ms.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -557,7 +557,7 @@
     pt_gc_stop_mark(interp);
 
     /* Note it */
-    mem_pools->gc_mark_runs++;
+    ++mem_pools->gc_mark_runs;
     --mem_pools->gc_mark_block_level;
     mem_pools->header_allocs_since_last_collect = 0;
 
@@ -689,7 +689,7 @@
 
     PObj_flags_SETTO((PObj *)pmc, PObj_on_free_list_FLAG);
     pool->add_free_object(interp, interp->mem_pools, pool, (PObj *)pmc);
-    pool->num_free_objects++;
+    ++pool->num_free_objects;
 }
 
 /*
@@ -735,7 +735,7 @@
         Fixed_Size_Pool * const pool = interp->mem_pools->string_header_pool;
         PObj_flags_SETTO((PObj *)s, PObj_on_free_list_FLAG);
         pool->add_free_object(interp, interp->mem_pools, pool, s);
-        pool->num_free_objects++;
+        ++pool->num_free_objects;
     }
 }
 
@@ -882,7 +882,7 @@
     pool->newlast   = (PMC_Attribute_Free_List *)((char *)next + item_space);
 #else
     pool->free_list = next;
-    for (i = 0; i < num_items; i++) {
+    for (i = 0; i < num_items; ++i) {
         list        = next;
         list->next  = (PMC_Attribute_Free_List *)((char *)list + item_size);
         next        = list->next;
@@ -1049,7 +1049,7 @@
     item->next      = pool->free_list;
     pool->free_list = item;
 
-    pool->num_free_objects++;
+    ++pool->num_free_objects;
 }
 
 /*
@@ -1595,7 +1595,7 @@
         Fixed_Size_Arena * const arena = pool->last_Arena;
         ptr           = (PObj *)pool->newfree;
         pool->newfree = (void *)((char *)pool->newfree + pool->object_size);
-        arena->used++;
+        ++arena->used;
 
         if (pool->newfree >= pool->newlast)
             pool->newfree = NULL;
@@ -1711,7 +1711,7 @@
 gc_ms_block_GC_mark(PARROT_INTERP)
 {
     ASSERT_ARGS(gc_ms_block_GC_mark)
-    interp->mem_pools->gc_mark_block_level++;
+    ++interp->mem_pools->gc_mark_block_level;
     Parrot_shared_gc_block(interp);
 }
 
@@ -1729,7 +1729,7 @@
 gc_ms_block_GC_sweep(PARROT_INTERP)
 {
     ASSERT_ARGS(gc_ms_block_GC_sweep)
-    interp->mem_pools->gc_sweep_block_level++;
+    ++interp->mem_pools->gc_sweep_block_level;
 }
 
 static void
@@ -1818,7 +1818,7 @@
 {
     ASSERT_ARGS(gc_ms_active_sized_buffers)
     int j, ret = 0;
-    for (j = 0; j < (INTVAL)mem_pools->num_sized; j++) {
+    for (j = 0; j < (INTVAL)mem_pools->num_sized; ++j) {
         Fixed_Size_Pool * const header_pool =
             mem_pools->sized_header_pools[j];
         if (header_pool)
@@ -1843,7 +1843,7 @@
 {
     ASSERT_ARGS(gc_ms_total_sized_buffers)
     int j, ret = 0;
-    for (j = 0; j < (INTVAL)mem_pools->num_sized; j++) {
+    for (j = 0; j < (INTVAL)mem_pools->num_sized; ++j) {
         Fixed_Size_Pool * const header_pool =
             mem_pools->sized_header_pools[j];
         if (header_pool)

Modified: trunk/src/gc/malloc.c
==============================================================================
--- trunk/src/gc/malloc.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/gc/malloc.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -4913,7 +4913,7 @@
           }
           / / save ptrs so they can be freed during cleanup
           our_os_pools[next_os_pool] = ptr;
-          next_os_pool++;
+          ++next_os_pool;
           ptr = (void *) ((((CHUNK_SIZE_T) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
           sbrk_top = (char *) ptr + size;
           return ptr;

Modified: trunk/src/gc/malloc_trace.c
==============================================================================
--- trunk/src/gc/malloc_trace.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/gc/malloc_trace.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -76,9 +76,9 @@
     if (fd2>=0 && (count = read(fd2, cmdline, 127)) > 0) {
         close(fd2);
         cmdline[count] = 0;
-        for (s=cmdline; *s++;); s--;
+        for (s=cmdline; ++*s;); --s;
         while (--s>cmdline && *s!='/');
-        if (*s == '/') s++;
+        if (*s == '/') ++s;
         sprintf(name, LOG_NAME ".%.12s.%d", s, pid);
     }
         else {
@@ -116,7 +116,7 @@
     buffer[buffer_i].size = t.tv_sec;
     buffer[buffer_i].ptr = (void *)t.tv_usec;
     buffer[buffer_i].ptr2 = NULL;
-    buffer_i++;
+    ++buffer_i;
     if (fd < 0) open_log_file();
     if (getpid() != pid) { /* Oops, must have forked... */
         if (fd >= 0) close(fd);
@@ -176,7 +176,7 @@
         buffer[buffer_i].size = t.tv_sec;
         buffer[buffer_i].ptr = (void *)t.tv_usec;
         buffer[buffer_i].ptr2 = NULL;
-        buffer_i++;
+        ++buffer_i;
     }
     buffer[buffer_i].code = code;
     buffer[buffer_i].size = size;

Modified: trunk/src/gc/mark_sweep.c
==============================================================================
--- trunk/src/gc/mark_sweep.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/gc/mark_sweep.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -268,12 +268,12 @@
         b = (PObj *)cur_arena->start_objects;
 
         /* loop only while there are objects in the arena */
-        for (i = objects_end; i; i--) {
+        for (i = objects_end; i; --i) {
 
             /* if it's on free list, do nothing */
 
             if (PObj_live_TEST(b)) {
-                total_used++;
+                ++total_used;
                 PObj_live_CLEAR(b);
                 PObj_get_FLAGS(b) &= ~PObj_custom_GC_FLAG;
             }
@@ -414,7 +414,7 @@
         Buffer *b = (Buffer *)arena->start_objects;
         UINTVAL i;
 
-        for (i = 0; i < arena->used; i++) {
+        for (i = 0; i < arena->used; ++i) {
             PObj_live_CLEAR(b);
             b = (Buffer *)((char *)b + object_size);
         }
@@ -456,7 +456,7 @@
 #else
     /* Move all the new objects into the free list */
     arena->used          = num_objects;
-    for (i = 0; i < num_objects; i++) {
+    for (i = 0; i < num_objects; ++i) {
         pool->add_free_object(interp, pool, object);
         object = (void *)((char *)object + pool->object_size);
     }

Modified: trunk/src/gc/system.c
==============================================================================
--- trunk/src/gc/system.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/gc/system.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -277,7 +277,7 @@
     size_t         max        = 0;
     UINTVAL        i;
 
-    for (i = 0; i < mem_pools->num_sized; i++) {
+    for (i = 0; i < mem_pools->num_sized; ++i) {
         if (mem_pools->sized_header_pools[i]) {
             if (mem_pools->sized_header_pools[i]->end_arena_memory > max)
                 max = mem_pools->sized_header_pools[i]->end_arena_memory;
@@ -311,7 +311,7 @@
     size_t         min        = (size_t) -1;
     UINTVAL        i;
 
-    for (i = 0; i < mem_pools->num_sized; i++) {
+    for (i = 0; i < mem_pools->num_sized; ++i) {
         const Fixed_Size_Pool * const pool = mem_pools->sized_header_pools[i];
         if (pool && pool->start_arena_memory) {
             if (pool->start_arena_memory < min)
@@ -387,7 +387,7 @@
     /* Shifting a value by its size (in bits) or larger is undefined behaviour.
        So need an explicit check to return 0 if there is no prefix, rather than
        attempting to rely on (say) 0xFFFFFFFF << 32 being 0.  */
-    for (i = 0; i < bound; i++) {
+    for (i = 0; i < bound; ++i) {
         if (val1 == val2)
             return ~(size_t)0 << i;
 
@@ -494,7 +494,7 @@
     ASSERT_ARGS(is_buffer_ptr)
     UINTVAL        i;
 
-    for (i = 0; i < mem_pools->num_sized; i++) {
+    for (i = 0; i < mem_pools->num_sized; ++i) {
         if (mem_pools->sized_header_pools[i]
             &&  contained_in_pool(mem_pools->sized_header_pools[i], ptr))
             return 1;

Modified: trunk/src/hash.c
==============================================================================
--- trunk/src/hash.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/hash.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -645,7 +645,7 @@
     ASSERT_ARGS(hash_freeze)
     size_t           i;
 
-    for (i = 0; i < hash->entries; i++) {
+    for (i = 0; i < hash->entries; ++i) {
         HashBucket * const b = hash->bs+i;
 
         switch (hash->key_type) {
@@ -1063,7 +1063,7 @@
     ASSERT_ARGS(parrot_chash_destroy)
     UINTVAL i;
 
-    for (i = 0; i <= hash->mask; i++) {
+    for (i = 0; i <= hash->mask; ++i) {
         HashBucket *bucket = hash->bi[i];
         while (bucket) {
             mem_gc_free(interp, bucket->key);
@@ -1098,7 +1098,7 @@
     ASSERT_ARGS(parrot_chash_destroy_values)
     UINTVAL i;
 
-    for (i = 0; i <= hash->mask; i++) {
+    for (i = 0; i <= hash->mask; ++i) {
         HashBucket *bucket = hash->bi[i];
         while (bucket) {
             mem_gc_free(interp, bucket->key);
@@ -1226,7 +1226,7 @@
         const UINTVAL  entries = hash->entries;
         UINTVAL        i;
 
-        for (i = 0; i < entries; i++) {
+        for (i = 0; i < entries; ++i) {
             HashBucket * const bucket = hash->bs + i;
 
             /* the hash->compare cost is too high for this fast path */
@@ -1353,7 +1353,7 @@
             bucket = hash->free_list;
         }
 
-        hash->entries++;
+        ++hash->entries;
         hash->free_list                = bucket->next;
         bucket->key                    = key;
         bucket->value                  = value;
@@ -1423,7 +1423,7 @@
     UINTVAL entries = hash->entries;
     UINTVAL i;
 
-    for (i = 0; i < entries; i++) {
+    for (i = 0; i < entries; ++i) {
         void         *valtmp;
         HashBucket   *b   = hash->bs+i;
         void * const  key = b->key;

Modified: trunk/src/interp/inter_misc.c
==============================================================================
--- trunk/src/interp/inter_misc.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/interp/inter_misc.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -336,10 +336,10 @@
                 while (pos              >  0
                 &&     fullname_c[pos] != '/'
                 &&     fullname_c[pos] != '\\')
-                    pos--;
+                    --pos;
 
                 if (pos > 0)
-                    pos++;
+                    ++pos;
 
                 basename = Parrot_str_new(interp, fullname_c + pos, 0);
                 Parrot_str_free_cstring(fullname_c);

Modified: trunk/src/io/buffer.c
==============================================================================
--- trunk/src/io/buffer.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/io/buffer.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -481,7 +481,7 @@
     buf_start = buffer_next;
 
     for (l = 0; buffer_next < buffer_end;) {
-        l++;
+        ++l;
         if (io_is_end_of_line((char *)buffer_next)) {
             Parrot_io_set_buffer_next(interp, filehandle, ++buffer_next);
             break;

Modified: trunk/src/io/core.c
==============================================================================
--- trunk/src/io/core.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/io/core.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -124,7 +124,7 @@
     /* this was i < PIO_NR_OPEN, but only standard handles 0..2 need
      * to be kept alive AFAIK -leo
      */
-    for (i = 0; i < 3; i++) {
+    for (i = 0; i < 3; ++i) {
         Parrot_gc_mark_PMC_alive(interp, table[i]);
     }
 }

Modified: trunk/src/longopt.c
==============================================================================
--- trunk/src/longopt.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/longopt.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -145,13 +145,13 @@
     const struct longopt_opt_decl* dptr;
 
     while (argv[dex][optlen] != '\0' && argv[dex][optlen] != '=') {
-        optlen++;
+        ++optlen;
     }
 
-    for (dptr = options; dptr->opt_id; dptr++) {
+    for (dptr = options; dptr->opt_id; ++dptr) {
         int sptr;
         /* For each listed long option... */
-        for (sptr = 0; dptr->opt_long[sptr]; sptr++) {
+        for (sptr = 0; dptr->opt_long[sptr]; ++sptr) {
             if (strncmp(dptr->opt_long[sptr], argv[dex], optlen) == 0
              && dptr->opt_long[sptr][optlen] == '\0') {
                 /* Found it */
@@ -246,7 +246,7 @@
         info_buf->_shortopt_pos = &argv[dex][1];
     pos = info_buf->_shortopt_pos;
 
-    for (dptr = options; dptr->opt_id; dptr++) {
+    for (dptr = options; dptr->opt_id; ++dptr) {
         if (dptr->opt_short == *pos) {
             /* Found it */
             info_buf->opt_id = dptr->opt_id;

Modified: trunk/src/main.c
==============================================================================
--- trunk/src/main.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/main.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -206,7 +206,7 @@
 is_all_hex_digits(ARGIN(const char *s))
 {
     ASSERT_ARGS(is_all_hex_digits)
-    for (; *s; s++)
+    for (; *s; ++s)
         if (!isxdigit(*s))
             return 0;
     return 1;
@@ -402,7 +402,7 @@
         else if (!strncmp(arg, "--hash-seed", 11)) {
 
             if ((arg = strrchr(arg, '=')))
-                arg++;
+                ++arg;
             else
                 arg = argv[++pos];
 

Modified: trunk/src/multidispatch.c
==============================================================================
--- trunk/src/multidispatch.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/multidispatch.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -396,7 +396,7 @@
             enum_class_FixedIntegerArray, param_count);
     INTVAL i;
 
-    for (i = 0; i < param_count; i++) {
+    for (i = 0; i < param_count; ++i) {
         STRING *type_name = VTABLE_get_string_keyed_int(interp, type_list, i);
         INTVAL  type;
 
@@ -646,7 +646,7 @@
             if (type_sig == enum_class_Integer) { dist++; continue; }
             if (type_sig == enum_type_PMC ||
                 (type_sig >= enum_class_default && type_sig < enum_class_core_max)) {
-                dist++;
+                ++dist;
                 type_call = enum_class_Integer;
             }
             break;
@@ -654,7 +654,7 @@
             if (type_sig == enum_class_Float)   { dist++; continue; }
             if (type_sig == enum_type_PMC ||
                 (type_sig >= enum_class_default && type_sig < enum_class_core_max)) {
-                dist++;
+                ++dist;
                 type_call = enum_class_Float;
             }
             break;
@@ -662,7 +662,7 @@
             if (type_sig == enum_class_String)  { dist++; continue; }
             if (type_sig == enum_type_PMC ||
                 (type_sig >= enum_class_default && type_sig < enum_class_core_max)) {
-                dist++;
+                ++dist;
                 type_call = enum_class_String;
             }
             break;
@@ -675,7 +675,7 @@
          * which matches any PMC
          */
         if (type_call <= 0 && type_sig == enum_type_PMC) {
-            dist++;
+            ++dist;
             continue;
         }
 
@@ -1122,7 +1122,7 @@
     STRING *key;
     INTVAL  i;
 
-    for (i = 0; i < num_values; i++) {
+    for (i = 0; i < num_values; ++i) {
         const INTVAL id = VTABLE_type(interp, VTABLE_get_pmc_keyed_int(interp, values, i));
         if (id == 0) {
             mem_gc_free(interp, type_ids);
@@ -1223,7 +1223,7 @@
     STRING *key;
     INTVAL  i;
 
-    for (i = 0; i < num_types; i++) {
+    for (i = 0; i < num_types; ++i) {
         const INTVAL id = VTABLE_get_integer_keyed_int(interp, types, i);
 
         if (id == 0) {

Modified: trunk/src/nci_test.c
==============================================================================
--- trunk/src/nci_test.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/nci_test.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -892,10 +892,10 @@
 nci_cb_D4(cb_D4_func times_ten, void* user_data)
 {
     int cnt;
-    for (cnt = 0; cnt < 9; cnt++)
+    for (cnt = 0; cnt < 9; ++cnt)
     {
         (times_ten)(user_data, &int_cb_D4);
-        int_cb_D4++;
+        ++int_cb_D4;
     }
 
     return;

Modified: trunk/src/oo.c
==============================================================================
--- trunk/src/oo.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/oo.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -267,7 +267,7 @@
     cloned_guts->attrib_store = NULL; /* XXX Do we need to set ->attrib_store twice? */
     cloned_guts->attrib_store = VTABLE_clone(interp, obj->attrib_store);
     num_attrs                 = VTABLE_elements(interp, cloned_guts->attrib_store);
-    for (i = 0; i < num_attrs; i++) {
+    for (i = 0; i < num_attrs; ++i) {
         PMC * const to_clone = VTABLE_get_pmc_keyed_int(interp, cloned_guts->attrib_store, i);
         if (!PMC_IS_NULL(to_clone)) {
             VTABLE_set_pmc_keyed_int(interp, cloned_guts->attrib_store, i,
@@ -280,7 +280,7 @@
     if (CLASS_has_alien_parents_TEST(obj->_class)) {
         int j;
         /* Locate any PMC parents. */
-        for (j = 0; j < num_classes; j++) {
+        for (j = 0; j < num_classes; ++j) {
             PMC * const cur_class = VTABLE_get_pmc_keyed_int(interp, _class->all_parents, j);
             if (cur_class->vtable->base_type == enum_class_PMCProxy) {
                 /* Clone this PMC too. */
@@ -472,7 +472,7 @@
         const INTVAL num_classes = VTABLE_elements(interp, _class->all_parents);
         INTVAL       i;
 
-        for (i = 0; i < num_classes; i++) {
+        for (i = 0; i < num_classes; ++i) {
             /* Get the class. */
             PMC * const cur_class =
                 VTABLE_get_pmc_keyed_int(interp, _class->all_parents, i);
@@ -688,7 +688,7 @@
     if (!mc)
         return;
 
-    for (type = 0; type < mc->mc_size; type++) {
+    for (type = 0; type < mc->mc_size; ++type) {
         if (!mc->idx[type])
             continue;
 
@@ -741,7 +741,7 @@
     Caches * const mc = interp->caches;
 
     /* mc->idx[type][bits] = e; */
-    for (i = 0; i < mc->mc_size; i++) {
+    for (i = 0; i < mc->mc_size; ++i) {
         if (mc->idx[i])
             invalidate_type_caches(interp, i);
     }
@@ -1097,7 +1097,7 @@
 
     /* Try and find something appropriate to add to the MRO - basically, the
      * first list head that is not in the tail of all the other lists. */
-    for (i = 0; i < list_count; i++) {
+    for (i = 0; i < list_count; ++i) {
         PMC * const cand_list = VTABLE_get_pmc_keyed_int(interp, merge_list, i);
 
         PMC *cand_class;
@@ -1108,9 +1108,9 @@
             continue;
 
         cand_class = VTABLE_get_pmc_keyed_int(interp, cand_list, 0);
-        cand_count++;
+        ++cand_count;
 
-        for (j = 0; j < list_count; j++) {
+        for (j = 0; j < list_count; ++j) {
             /* Skip the current list. */
             if (j != i) {
                 /* Is it in the tail? If so, reject. */
@@ -1120,7 +1120,7 @@
                 const int check_length = VTABLE_elements(interp, check_list);
                 int k;
 
-                for (k = 1; k < check_length; k++) {
+                for (k = 1; k < check_length; ++k) {
                     if (VTABLE_get_pmc_keyed_int(interp, check_list, k) ==
                         cand_class) {
                         reject = 1;
@@ -1147,13 +1147,13 @@
             "Could not build C3 linearization: ambiguous hierarchy");
 
     /* Otherwise, remove what was accepted from the merge lists. */
-    for (i = 0; i < list_count; i++) {
+    for (i = 0; i < list_count; ++i) {
 
         PMC * const list           = VTABLE_get_pmc_keyed_int(interp, merge_list, i);
         const INTVAL sublist_count = VTABLE_elements(interp, list);
         INTVAL j;
 
-        for (j = 0; j < sublist_count; j++) {
+        for (j = 0; j < sublist_count; ++j) {
             if (VTABLE_get_pmc_keyed_int(interp, list, j) == accepted) {
                 VTABLE_delete_keyed_int(interp, list, j);
                 break;
@@ -1217,7 +1217,7 @@
     /* Otherwise, need to do merge. For that, need linearizations of all of
      * our parents added to the merge list. */
     merge_list = PMCNULL;
-    for (i = 0; i < parent_count; i++) {
+    for (i = 0; i < parent_count; ++i) {
         PMC * const lin = Parrot_ComputeMRO_C3(interp,
             VTABLE_get_pmc_keyed_int(interp, immediate_parents, i));
 
@@ -1285,7 +1285,7 @@
     /* Check we have not already composed the role; if so, just ignore it. */
     INTVAL roles_count = VTABLE_elements(interp, roles_list);
 
-    for (i = 0; i < roles_count; i++)
+    for (i = 0; i < roles_count; ++i)
         if (VTABLE_get_pmc_keyed_int(interp, roles_list, i) == role)
             return;
 
@@ -1313,7 +1313,7 @@
         if (got_exclude) {
             const int exclude_count = VTABLE_elements(interp, exclude);
 
-            for (i = 0; i < exclude_count; i++) {
+            for (i = 0; i < exclude_count; ++i) {
                 const STRING * const check =
                     VTABLE_get_string_keyed_int(interp, exclude, i);
 
@@ -1409,7 +1409,7 @@
                 /* Class already has a multi-sub; need to merge our methods into it. */
                 const INTVAL num_subs = VTABLE_elements(interp, cur_method);
                 INTVAL j;
-                for (j = 0; j < num_subs; j++)
+                for (j = 0; j < num_subs; ++j)
                     VTABLE_push_pmc(interp, cur_entry, VTABLE_get_pmc_keyed_int(interp,
                             cur_method, j));
             }
@@ -1429,7 +1429,7 @@
 
     /* Add this role to the roles list. */
     VTABLE_push_pmc(interp, roles_list, role);
-    roles_count++;
+    ++roles_count;
 
     /* As a result of composing this role, we will also now do the roles
      * that it did itself. Note that we already have the correct methods
@@ -1438,13 +1438,13 @@
     Parrot_pcc_invoke_method_from_c_args(interp, role, CONST_STRING(interp, "roles"), "->P", &roles_of_role);
     roles_of_role_count = VTABLE_elements(interp, roles_of_role);
 
-    for (i = 0; i < roles_of_role_count; i++) {
+    for (i = 0; i < roles_of_role_count; ++i) {
         /* Only add if we don't already have it in the list. */
         PMC * const cur_role = VTABLE_get_pmc_keyed_int(interp,
                                     roles_of_role, i);
         INTVAL j;
 
-        for (j = 0; j < roles_count; j++) {
+        for (j = 0; j < roles_count; ++j) {
             if (VTABLE_get_pmc_keyed_int(interp, roles_list, j) == cur_role) {
                 /* We ain't be havin' it. */
                 VTABLE_push_pmc(interp, roles_list, cur_role);

Modified: trunk/src/packdump.c
==============================================================================
--- trunk/src/packdump.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/packdump.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -67,7 +67,7 @@
     ASSERT_ARGS(PackFile_ConstTable_dump)
     opcode_t i;
 
-    for (i = 0; i < self->const_count; i++) {
+    for (i = 0; i < self->const_count; ++i) {
         Parrot_io_printf(interp, "    # %ld:\n", (long)i);
         PackFile_Constant_dump(interp, self, self->constants[i]);
     }
@@ -144,9 +144,9 @@
             if (printed_flag_p)
                 Parrot_io_printf(interp, ",");
             Parrot_io_printf(interp, "%s", flag_bit_names[idx]);
-            printed_flag_p++;
+            ++printed_flag_p;
         }
-        idx++;
+        ++idx;
         flags >>= 1;
     }
     Parrot_io_printf(interp, ")\n");
@@ -181,7 +181,7 @@
         break;
 
       case PFC_KEY:
-        for (i = 0, key = self->u.key; key; i++) {
+        for (i = 0, key = self->u.key; key; ++i) {
             GETATTR_Key_next_key(interp, key, key);
         }
         /* number of key components */
@@ -376,7 +376,7 @@
     ASSERT_ARGS(PackFile_Fixup_dump)
     opcode_t i;
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         Parrot_io_printf(interp, "\t#%d\n", (int) i);
         switch (ft->fixups[i].type) {
           case enum_fixup_label:

Modified: trunk/src/packfile.c
==============================================================================
--- trunk/src/packfile.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/packfile.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -818,7 +818,7 @@
     PackFile_Constant ** const constants = find_constants(interp, ct);
     opcode_t i;
 
-    for (i = 0; i < ct->const_count; i++) {
+    for (i = 0; i < ct->const_count; ++i) {
         PMC    * pmc;
         STRING * string;
         switch (constants[i]->type) {
@@ -929,7 +929,7 @@
 
     TRACE_PRINTF(("PackFile: do_sub_pragmas (action=%d)\n", action));
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         switch (ft->fixups[i].type) {
             case enum_fixup_sub:
             {
@@ -1176,7 +1176,7 @@
     ASSERT_ARGS(PackFile_map_segments)
     size_t i;
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         const INTVAL ret = callback(interp, dir->segments[i], user_data);
         if (ret)
             return ret;
@@ -1207,7 +1207,7 @@
     dir->segments = mem_gc_realloc_n_typed_zeroed(interp, dir->segments,
             dir->num_segments + 1, dir->num_segments, PackFile_Segment *);
     dir->segments[dir->num_segments] = seg;
-    dir->num_segments++;
+    ++dir->num_segments;
     seg->dir = dir;
 
     return;
@@ -1238,7 +1238,7 @@
     if (dir) {
         size_t i;
 
-        for (i = 0; i < dir->num_segments; i++) {
+        for (i = 0; i < dir->num_segments; ++i) {
             PackFile_Segment *seg = dir->segments[i];
 
             if (seg) {
@@ -1282,7 +1282,7 @@
     ASSERT_ARGS(PackFile_remove_segment_by_name)
     size_t i;
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         PackFile_Segment * const seg = dir->segments[i];
         if (Parrot_str_equal(interp, seg->name, name)) {
             dir->num_segments--;
@@ -1537,7 +1537,7 @@
         int i;
         TRACE_PRINTF(("default_unpack: pre-fetch %d ops into data\n",
                       self->size));
-        for (i = 0; i < (int)self->size; i++) {
+        for (i = 0; i < (int)self->size; ++i) {
             self->data[i] = PF_fetch_opcode(self->pf, &cursor);
             TRACE_PRINTF(("default_unpack: transformed op[#%d]/%d %u\n",
                           i, self->size, self->data[i]));
@@ -1592,7 +1592,7 @@
         Parrot_io_printf(interp, "\n %04x:  ", (int) i);
 
     for (; i < (self->data ? self->size :
-            self->file_offset + self->op_count); i++) {
+            self->file_offset + self->op_count); ++i) {
 
         if (i % 8 == 0)
             Parrot_io_printf(interp, "\n %04x:  ", (int) i);
@@ -2027,7 +2027,7 @@
 
     Parrot_io_printf(interp, "\n\t# %d segments\n", dir->num_segments);
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         const PackFile_Segment * const seg = dir->segments[i];
 
         Parrot_io_printf(interp,
@@ -2042,7 +2042,7 @@
 
     Parrot_io_printf(interp, "]\n");
 
-    for (i = 0; i < dir->num_segments; i++)
+    for (i = 0; i < dir->num_segments; ++i)
         PackFile_Segment_dump(interp, dir->segments[i]);
 }
 
@@ -2076,7 +2076,7 @@
     dir->segments = mem_gc_allocate_n_zeroed_typed(interp,
             dir->num_segments, PackFile_Segment *);
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         PackFile_Segment *seg;
         char             *buf;
         STRING           *name;
@@ -2155,7 +2155,7 @@
                       offs, pf->src, cursor));
 
     /* and now unpack contents of dir */
-    for (i = 0; cursor && i < dir->num_segments; i++) {
+    for (i = 0; cursor && i < dir->num_segments; ++i) {
         const opcode_t * const csave = cursor;
 
         /* check len again */
@@ -2223,7 +2223,7 @@
     PackFile_Directory * const dir = (PackFile_Directory *)self;
     size_t i;
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         PackFile_Segment *segment = dir->segments[i];
         /* Prevent repeated destruction */
         dir->segments[i] = NULL;
@@ -2260,7 +2260,7 @@
     if (seg->type != PF_BYTEC_SEG) {
         size_t i;
 
-        for (i = 1; i < num_segs; i++) {
+        for (i = 1; i < num_segs; ++i) {
             PackFile_Segment * const s2 = dir->segments[i];
             if (s2->type == PF_BYTEC_SEG) {
                 dir->segments[0] = s2;
@@ -2275,7 +2275,7 @@
     if (seg->type != PF_FIXUP_SEG) {
         size_t i;
 
-        for (i = 2; i < num_segs; i++) {
+        for (i = 2; i < num_segs; ++i) {
             PackFile_Segment * const s2 = dir->segments[i];
             if (s2->type == PF_FIXUP_SEG) {
                 dir->segments[1] = s2;
@@ -2295,7 +2295,7 @@
     if (seg->type != PF_CONST_SEG) {
         size_t i;
 
-        for (i = 3; i < num_segs; i++) {
+        for (i = 3; i < num_segs; ++i) {
             PackFile_Segment * const s2 = dir->segments[i];
             if (s2->type == PF_CONST_SEG) {
                 dir->segments[2] = s2;
@@ -2334,7 +2334,7 @@
     /* number of segments + default, we need it for the offsets */
     size = 1 + default_packed_size(self);
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         char *name = Parrot_str_to_cstring(interp, dir->segments[i]->name);
         /* type, offset, size */
         size += 3;
@@ -2346,7 +2346,7 @@
     if (align && size % align)
         size += (align - size % align);
 
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         size_t seg_size;
 
         dir->segments[i]->file_offset = size + self->file_offset;
@@ -2413,7 +2413,7 @@
       cursor += align - (cursor - self->pf->src) % align;*/
 
     /* now pack all segments into new format */
-    for (i = 0; i < dir->num_segments; i++) {
+    for (i = 0; i < dir->num_segments; ++i) {
         PackFile_Segment * const seg = dir->segments[i];
 
         cursor = PackFile_Segment_pack(interp, seg, cursor);
@@ -2718,7 +2718,7 @@
     *cursor++ = n;
 
     /* Now store each mapping. */
-    for (i = 0; i < n; i++) {
+    for (i = 0; i < n; ++i) {
         /* Bytecode offset and filename. */
         *cursor++ = debug->mappings[i].offset;
         *cursor++ = debug->mappings[i].filename;
@@ -2764,7 +2764,7 @@
             debug->num_mappings, PackFile_DebugFilenameMapping);
 
     /* Read in each mapping. */
-    for (i = 0; i < debug->num_mappings; i++) {
+    for (i = 0; i < debug->num_mappings; ++i) {
         /* Get offset and filename type. */
         debug->mappings[i].offset   = PF_fetch_opcode(self->pf, &cursor);
         debug->mappings[i].filename = PF_fetch_opcode(self->pf, &cursor);
@@ -2809,7 +2809,7 @@
     default_dump_header(interp, self);
 
     Parrot_io_printf(interp, "\n  mappings => [\n");
-    for (i = 0; i < debug->num_mappings; i++) {
+    for (i = 0; i < debug->num_mappings; ++i) {
         Parrot_io_printf(interp, "    #%d\n    [\n", i);
         Parrot_io_printf(interp, "        OFFSET => %d,\n",
                    debug->mappings[i].offset);
@@ -2919,7 +2919,7 @@
         /* Find the right place and shift stuff that's after it. */
         int i;
 
-        for (i = 0; i < debug->num_mappings; i++) {
+        for (i = 0; i < debug->num_mappings; ++i) {
             if (debug->mappings[i].offset > offset) {
                 insert_pos = i;
                 memmove(debug->mappings + i + 1, debug->mappings + i,
@@ -2995,7 +2995,7 @@
        bytecode offset. */
 
     int i;
-    for (i = 0; i < debug->num_mappings; i++) {
+    for (i = 0; i < debug->num_mappings; ++i) {
         /* If this is the last mapping or the current position is
            between this mapping and the next one, return a filename. */
        if (i + 1                          == debug->num_mappings
@@ -3032,14 +3032,14 @@
     opcode_t n;
 
     /* TODO make an index of code segments for faster look up */
-    for (i = n = 0; i < num_segs; i++) {
+    for (i = n = 0; i < num_segs; ++i) {
         if (dir->segments[i]->type == PF_BYTEC_SEG) {
             if (n == seg) {
                 Parrot_switch_to_cs(interp, (PackFile_ByteCode *)
                         dir->segments[i], 1);
                 return;
             }
-            n++;
+            ++n;
         }
     }
 
@@ -3278,7 +3278,7 @@
 
     if (self->fixup_count) {
         opcode_t i;
-        for (i = 0; i < self->fixup_count; i++) {
+        for (i = 0; i < self->fixup_count; ++i) {
             mem_gc_free(interp, self->fixups[i].name);
             self->fixups[i].name = NULL;
         }
@@ -3328,14 +3328,14 @@
     size_t                      size = 1;
     opcode_t i;
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         /* fixup_entry type */
-        size++;
+        ++size;
         switch (ft->fixups[i].type) {
           case enum_fixup_label:
           case enum_fixup_sub:
             size += PF_size_cstring(ft->fixups[i].name);
-            size ++; /* offset */
+            ++size; /* offset */
             break;
           case enum_fixup_none:
             break;
@@ -3371,7 +3371,7 @@
 
     *cursor++ = ft->fixup_count;
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         *cursor++ = (opcode_t) ft->fixups[i].type;
         switch (ft->fixups[i].type) {
           case enum_fixup_label:
@@ -3465,7 +3465,7 @@
         }
     }
 
-    for (i = 0; i < self->fixup_count; i++) {
+    for (i = 0; i < self->fixup_count; ++i) {
         PackFile_FixupEntry * const entry = self->fixups + i;
 
         entry->type = PF_fetch_opcode(pf, &cursor);
@@ -3555,7 +3555,7 @@
 {
     ASSERT_ARGS(find_fixup)
     opcode_t i;
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         if ((INTVAL)((enum_fixup_t)ft->fixups[i].type) == type
         &&  STREQ(ft->fixups[i].name, name)) {
             return ft->fixups + i;
@@ -3662,7 +3662,7 @@
     ASSERT_ARGS(PackFile_ConstTable_clear)
     opcode_t i;
 
-    for (i = 0; i < self->const_count; i++) {
+    for (i = 0; i < self->const_count; ++i) {
         PackFile_Constant_destroy(interp, self->constants[i]);
         self->constants[i] = NULL;
     }
@@ -3726,7 +3726,7 @@
         return NULL;
     }
 
-    for (i = 0; i < self->const_count; i++) {
+    for (i = 0; i < self->const_count; ++i) {
         TRACE_PRINTF(("PackFile_ConstTable_unpack(): Unpacking constant %ld/%ld\n",
             i, self->const_count));
         self->constants[i] = PackFile_Constant_new(interp);
@@ -4123,7 +4123,7 @@
 
     /* Free any keys. */
     if (self->keys) {
-        for (i = 0; i < self->num_keys; i++)
+        for (i = 0; i < self->num_keys; ++i)
             mem_gc_free(interp, self->keys[i]);
 
         mem_gc_free(interp, self->keys);
@@ -4131,14 +4131,14 @@
 
     /* Free any groups. */
     if (self->groups) {
-        for (i = 0; i < self->num_groups; i++)
+        for (i = 0; i < self->num_groups; ++i)
             mem_gc_free(interp, self->groups[i]);
         mem_gc_free(interp, self->groups);
     }
 
     /* Free any entries. */
     if (self->entries) {
-        for (i = 0; i < self->num_entries; i++)
+        for (i = 0; i < self->num_entries; ++i)
             mem_gc_free(interp, self->entries[i]);
         mem_gc_free(interp, self->entries);
     }
@@ -4194,7 +4194,7 @@
     /* Write key count and any keys. */
     *cursor++ = self->num_keys;
 
-    for (i = 0; i < self->num_keys; i++) {
+    for (i = 0; i < self->num_keys; ++i) {
         const PackFile_Annotations_Key * const key = self->keys[i];
         *cursor++ = key->name;
         *cursor++ = key->type;
@@ -4203,7 +4203,7 @@
     /* Write group count and any groups. */
     *cursor++ = self->num_groups;
 
-    for (i = 0; i < self->num_groups; i++) {
+    for (i = 0; i < self->num_groups; ++i) {
         const PackFile_Annotations_Group * const group = self->groups[i];
         *cursor++ = group->bytecode_offset;
         *cursor++ = group->entries_offset;
@@ -4212,7 +4212,7 @@
     /* Write entry count and any entries. */
     *cursor++ = self->num_entries;
 
-    for (i = 0; i < self->num_entries; i++) {
+    for (i = 0; i < self->num_entries; ++i) {
         const PackFile_Annotations_Entry * const entry = self->entries[i];
         *cursor++ = entry->bytecode_offset;
         *cursor++ = entry->key;
@@ -4257,7 +4257,7 @@
     self->keys     = mem_gc_allocate_n_zeroed_typed(interp,
             self->num_keys, PackFile_Annotations_Key *);
 
-    for (i = 0; i < self->num_keys; i++) {
+    for (i = 0; i < self->num_keys; ++i) {
         PackFile_Annotations_Key * const key = self->keys[i] =
                 mem_gc_allocate_zeroed_typed(interp, PackFile_Annotations_Key);
         key->name = PF_fetch_opcode(seg->pf, &cursor);
@@ -4271,7 +4271,7 @@
     self->groups     = mem_gc_allocate_n_zeroed_typed(interp,
             self->num_groups, PackFile_Annotations_Group *);
 
-    for (i = 0; i < self->num_groups; i++) {
+    for (i = 0; i < self->num_groups; ++i) {
         PackFile_Annotations_Group * const group =
             self->groups[i] = mem_gc_allocate_zeroed_typed(interp,
                     PackFile_Annotations_Group);
@@ -4287,7 +4287,7 @@
     self->num_entries = PF_fetch_opcode(seg->pf, &cursor);
     self->entries     = mem_gc_allocate_n_zeroed_typed(interp,
             self->num_entries, PackFile_Annotations_Entry *);
-    for (i = 0; i < self->num_entries; i++) {
+    for (i = 0; i < self->num_entries; ++i) {
         PackFile_Annotations_Entry * const entry =
             self->entries[i]   = mem_gc_allocate_zeroed_typed(interp,
                     PackFile_Annotations_Entry);
@@ -4337,7 +4337,7 @@
 
     /* Dump keys. */
     Parrot_io_printf(interp, "\n  keys => [\n");
-    for (i = 0; i < self->num_keys; i++) {
+    for (i = 0; i < self->num_keys; ++i) {
         const PackFile_Annotations_Key * const key = self->keys[i];
         Parrot_io_printf(interp, "    #%d\n    [\n", i);
         Parrot_io_printf(interp, "        NAME => %Ss\n",
@@ -4354,7 +4354,7 @@
 
     /* Dump groups. */
     Parrot_io_printf(interp, "\n  groups => [\n");
-    for (i = 0; i < self->num_groups; i++) {
+    for (i = 0; i < self->num_groups; ++i) {
         const PackFile_Annotations_Group * const group = self->groups[i];
         Parrot_io_printf(interp, "    #%d\n    [\n", i);
         Parrot_io_printf(interp, "        BYTECODE_OFFSET => %d\n",
@@ -4369,7 +4369,7 @@
     /* Dump entries. */
     Parrot_io_printf(interp, "\n  entries => [\n");
 
-    for (i = 0; i < self->num_entries; i++) {
+    for (i = 0; i < self->num_entries; ++i) {
         const PackFile_Annotations_Entry * const entry = self->entries[i];
         Parrot_io_printf(interp, "    #%d\n    [\n", i);
         Parrot_io_printf(interp, "        BYTECODE_OFFSET => %d\n",
@@ -4420,7 +4420,7 @@
     group->entries_offset  = self->num_entries;
 
     /* Increment group count. */
-    self->num_groups++;
+    ++self->num_groups;
 }
 
 
@@ -4451,7 +4451,7 @@
     opcode_t key_id   = -1;
     INTVAL   i;
 
-    for (i = 0; i < self->num_keys; i++) {
+    for (i = 0; i < self->num_keys; ++i) {
         STRING * const test_key = PF_CONST(self->code, self->keys[i]->name)->u.string;
         if (Parrot_str_equal(interp, test_key, key_name)) {
             key_id = i;
@@ -4470,7 +4470,7 @@
 
         key_id             = self->num_keys;
         self->keys[key_id] = mem_gc_allocate_typed(interp, PackFile_Annotations_Key);
-        self->num_keys++;
+        ++self->num_keys;
 
         /* Populate it. */
         self->keys[key_id]->name = key;
@@ -4499,7 +4499,7 @@
     self->entries[self->num_entries]->key             = key_id;
     self->entries[self->num_entries]->value           = value;
 
-    self->num_entries++;
+    ++self->num_entries;
 }
 
 
@@ -4572,7 +4572,7 @@
     opcode_t key_id = -1;
 
     if (!STRING_IS_NULL(key)) {
-        for (i = 0; i < self->num_keys; i++) {
+        for (i = 0; i < self->num_keys; ++i) {
             STRING * const test_key = PF_CONST(self->code, self->keys[i]->name)->u.string;
             if (Parrot_str_equal(interp, test_key, key)) {
                 key_id = i;
@@ -4585,7 +4585,7 @@
     }
 
     /* Use groups to find search start point. */
-    for (i = 0; i < self->num_groups; i++)
+    for (i = 0; i < self->num_groups; ++i)
         if (offset < self->groups[i]->bytecode_offset)
             break;
         else
@@ -4599,7 +4599,7 @@
         opcode_t *have_values   = mem_gc_allocate_n_zeroed_typed(interp,
                 self->num_keys, opcode_t);
 
-        for (i = start_entry; i < self->num_entries; i++) {
+        for (i = start_entry; i < self->num_entries; ++i) {
             if (self->entries[i]->bytecode_offset >= offset)
                 break;
 
@@ -4610,7 +4610,7 @@
         /* Create hash of values we have. */
         result = Parrot_pmc_new(interp, enum_class_Hash);
 
-        for (i = 0; i < self->num_keys; i++) {
+        for (i = 0; i < self->num_keys; ++i) {
             if (have_values[i]) {
                 STRING * const key_name = PF_CONST(self->code, self->keys[i]->name)->u.string;
                 VTABLE_set_pmc_keyed_str(interp, result, key_name,
@@ -4627,7 +4627,7 @@
         opcode_t latest_value = 0;
         opcode_t found_value  = 0;
 
-        for (i = start_entry; i < self->num_entries; i++) {
+        for (i = start_entry; i < self->num_entries; ++i) {
             if (self->entries[i]->bytecode_offset >= offset)
                 break;
 

Modified: trunk/src/packfile/pf_items.c
==============================================================================
--- trunk/src/packfile/pf_items.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/packfile/pf_items.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -323,7 +323,7 @@
         dest[7] |= 0x80;
     /* long double frac 63 bits => 52 bits
        src[7] &= 0x7f; reset integer bit */
-    for (i = 0; i < 6; i++) {
+    for (i = 0; i < 6; ++i) {
         dest[i+1] |= (i==5 ? src[7]&0x7f : src[i+2]) >> 3;
         dest[i] |= (src[i+2] & 0x1f) << 5;
     }
@@ -552,7 +552,7 @@
             dest[7] |= 0x80;
         /* long double frac 112 bits => 52 bits
            src[13] &= 0x7f; reset integer bit */
-        for (i = 0; i < 6; i++) {
+        for (i = 0; i < 6; ++i) {
             dest[i+1] |= (i==5 ? src[13]&0x7f : src[i+7]) >> 3;
             dest[i] |= (src[i+7] & 0x1f) << 5;
         }

Modified: trunk/src/packout.c
==============================================================================
--- trunk/src/packout.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/packout.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -112,7 +112,7 @@
     padding_size = 16 - (PACKFILE_HEADER_BYTES + self->header->uuid_size) % 16;
     if (padding_size < 16) {
         int i;
-        for (i = 0; i < padding_size; i++)
+        for (i = 0; i < padding_size; ++i)
             *byte_cursor++ = 0;
     }
     else {
@@ -162,7 +162,7 @@
     const PackFile_ConstTable* const self = (const PackFile_ConstTable *) seg;
     size_t size = 1;    /* const_count */
 
-    for (i = 0; i < self->const_count; i++)
+    for (i = 0; i < self->const_count; ++i)
         size += PackFile_Constant_pack_size(interp, self->constants[i]);
     return size;
 }
@@ -197,7 +197,7 @@
 
     *cursor++ = self->const_count;
 
-    for (i = 0; i < self->const_count; i++)
+    for (i = 0; i < self->const_count; ++i)
         cursor = PackFile_Constant_pack(interp, self, self->constants[i], cursor);
 
     return cursor;
@@ -228,7 +228,7 @@
     GETATTR_Key_str_key(interp, key, key_str);
     GETATTR_Key_num_key(interp, key, key_num);
 
-    for (i = 0; i < ct->const_count; i++) {
+    for (i = 0; i < ct->const_count; ++i) {
         if (type == PFC_STRING && ct->constants[i]->u.string == key_str)
             return i;
         if (type == PFC_NUMBER && ct->constants[i]->u.number == key_num)
@@ -291,7 +291,7 @@
         break;
 
       case PFC_KEY:
-        for (i = 0, key = self->u.key; key; i++){
+        for (i = 0, key = self->u.key; key; ++i){
             GETATTR_Key_next_key(interp, key, key);
         }
 

Modified: trunk/src/pbc_dump.c
==============================================================================
--- trunk/src/pbc_dump.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pbc_dump.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -124,7 +124,7 @@
         /* trace_op_dump(interp, self->pf->src, pc); */
         Parrot_io_printf(interp, " %04x:  ", (int)(pc - self->data));
 
-        for (i = 0; i < 6; i++)
+        for (i = 0; i < 6; ++i)
             if (i < n)
                 Parrot_io_printf(interp, "%08lx ", (unsigned long)pc[i]);
             else
@@ -210,7 +210,7 @@
     const PackFile_Directory * const dir = (const PackFile_Directory *)self;
     size_t i;
 
-    for (i = 0; i < dir->num_segments; i++)
+    for (i = 0; i < dir->num_segments; ++i)
         self->pf->PackFuncs[dir->segments[i]->type].dump(interp, dir->segments[i]);
 }
 
@@ -440,7 +440,7 @@
     if (nums_only) {
         int i;
 
-        for (i = PF_DIR_SEG + 1; i < PF_MAX_SEG; i++)
+        for (i = PF_DIR_SEG + 1; i < PF_MAX_SEG; ++i)
             pf->PackFuncs[i].dump = null_dump;
 
         pf->PackFuncs[PF_DIR_SEG].dump   = null_dir_dump;

Modified: trunk/src/pbc_merge.c
==============================================================================
--- trunk/src/pbc_merge.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pbc_merge.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -325,7 +325,7 @@
     }
 
     /* Loop over input files. */
-    for (i = 0; i < num_inputs; i++) {
+    for (i = 0; i < num_inputs; ++i) {
         /* Get the bytecode segment from the input file. */
         PackFile_ByteCode * const in_seg = inputs[i]->pf->cur_cs;
         if (in_seg == NULL) {
@@ -393,7 +393,7 @@
     }
 
     /* Loop over input files. */
-    for (i = 0; i < num_inputs; i++) {
+    for (i = 0; i < num_inputs; ++i) {
 
         /* Get the constant table segment from the input file. */
         PackFile_ConstTable * const in_seg = inputs[i]->pf->cur_cs->const_table;
@@ -414,7 +414,7 @@
                     cursor + in_seg->const_count, PackFile_Constant*);
 
         /* Loop over the constants and copy them to the output PBC. */
-        for (j = 0; j < in_seg->const_count; j++) {
+        for (j = 0; j < in_seg->const_count; ++j) {
             /* Get the entry and allocate space for copy. */
             PackFile_Constant *cur_entry = in_seg->constants[j];
             PackFile_Constant *copy      = mem_gc_allocate_typed(interp,
@@ -439,12 +439,12 @@
             }
 
             inputs[i]->const_map[input_const_num] = output_const_num;
-            input_const_num++;
-            output_const_num++;
+            ++input_const_num;
+            ++output_const_num;
 
             /* Slot it into the list. */
             constants[cursor] = copy;
-            cursor++;
+            ++cursor;
         }
     }
 
@@ -488,7 +488,7 @@
     }
 
     /* Loop over input files. */
-    for (i = 0; i < num_inputs; i++) {
+    for (i = 0; i < num_inputs; ++i) {
         /* Get the fixup segment from the input file. */
         PackFile_FixupTable * const in_seg = inputs[i]->pf->cur_cs->fixups;
         int j;
@@ -508,7 +508,7 @@
 
         /* Loop over the fixups and copy them to the output PBC, correcting
            the offsets into the bytecode. */
-        for (j = 0; j < in_seg->fixup_count; j++) {
+        for (j = 0; j < in_seg->fixup_count; ++j) {
             /* Get the entry and allocate space for copies. */
             const PackFile_FixupEntry * const cur_entry = in_seg->fixups + j;
             PackFile_FixupEntry * const copy =
@@ -536,7 +536,7 @@
 
             /* Slot it into the list. */
             fixups[cursor] = *copy;
-            cursor++;
+            ++cursor;
         }
     }
 
@@ -576,7 +576,7 @@
     /* We need to merge both the mappings and the list of line numbers.
        The line numbers can just be concatenated. The mappings must have
        their offsets fixed up. */
-    for (i = 0; i < num_inputs; i++) {
+    for (i = 0; i < num_inputs; ++i) {
         const PackFile_Debug * const in_seg = inputs[i]->pf->cur_cs->debugs;
         int j;
 
@@ -592,7 +592,7 @@
                 num_mappings + in_seg->num_mappings,
                 PackFile_DebugFilenameMapping);
 
-        for (j = 0; j < in_seg->num_mappings; j++) {
+        for (j = 0; j < in_seg->num_mappings; ++j) {
             PackFile_DebugFilenameMapping *mapping = mappings + num_mappings + j;
 
             STRUCT_COPY_FROM_STRUCT(mapping, in_seg->mappings[j]);
@@ -647,16 +647,16 @@
         /* Keep track of the current input file. */
         if (cur_input + 1 < num_inputs &&
             cur_op >= inputs[cur_input + 1]->code_start)
-            cur_input++;
+            ++cur_input;
 
         /* Get info about this op and jump over it. */
         op_num = ops[cur_op];
         op     = &interp->op_info_table[op_num];
         op_ptr = ops + cur_op;
-        cur_op++;
+        ++cur_op;
 
         /* Loop over the arguments. */
-        for (cur_arg = 1; cur_arg < op->op_count; cur_arg++) {
+        for (cur_arg = 1; cur_arg < op->op_count; ++cur_arg) {
             /* Pick out any indexes into the constant table and correct them. */
             switch (op->types[cur_arg - 1]) {
                 case PARROT_ARG_NC:
@@ -671,7 +671,7 @@
             }
 
             /* Move along the bytecode array. */
-            cur_op++;
+            ++cur_op;
         }
 
         /* Handle special case variable argument opcodes. */
@@ -684,7 +684,7 @@
 
             /* Loop over the arguments to locate any that need a fixup. */
             const int sig_items = VTABLE_elements(interp, sig);
-            for (cur_arg = 0; cur_arg < sig_items; cur_arg++) {
+            for (cur_arg = 0; cur_arg < sig_items; ++cur_arg) {
                 switch (VTABLE_get_integer_keyed_int(interp, sig, cur_arg)) {
                     case PARROT_ARG_NC:
                     case PARROT_ARG_PC:
@@ -696,7 +696,7 @@
                     default:
                         break;
                 }
-                cur_op++;
+                ++cur_op;
             }
         }
     }
@@ -731,10 +731,10 @@
     }
 
     /* calculate how many constants are stored in the packfiles to be merged */
-    for (i = 0; i < num_inputs; i++) {
+    for (i = 0; i < num_inputs; ++i) {
         PackFile_Directory *pf_dir = &inputs[i]->pf->directory;
         unsigned int j = 0;
-        for (j = 0; j < pf_dir->num_segments; j++) {
+        for (j = 0; j < pf_dir->num_segments; ++j) {
             PackFile_Segment *seg = (PackFile_Segment *)pf_dir->segments[j];
             if (seg->type == PF_CONST_SEG) {
                 opcode_t const_count = ((PackFile_ConstTable *)seg)->const_count;
@@ -755,7 +755,7 @@
     /* Walk bytecode and fix ops that reference the constants table. */
     pbc_merge_ctpointers(interp, inputs, num_inputs, bc);
 
-    for (i = 0; i < num_inputs; i++) {
+    for (i = 0; i < num_inputs; ++i) {
         mem_gc_free(interp, inputs[i]->const_map);
     }
 
@@ -861,7 +861,7 @@
        structure for each of them. */
     input_files = mem_gc_allocate_n_typed(interp, argc, pbc_merge_input*);
 
-    for (i = 0; i < argc; i++) {
+    for (i = 0; i < argc; ++i) {
         /* Allocate a struct. */
         input_files[i] = mem_gc_allocate_typed(interp, pbc_merge_input);
 
@@ -879,7 +879,7 @@
         }
 
         /* Next file. */
-        argv++;
+        ++argv;
     }
 
     /* Merge. */

Modified: trunk/src/pmc/callcontext.pmc
==============================================================================
--- trunk/src/pmc/callcontext.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/callcontext.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -382,7 +382,7 @@
         UINTVAL i, j = 0;
         result = Parrot_pmc_new_init_int(interp, enum_class_FixedStringArray, hash->entries);
 
-        for (i = 0; i <= hash->mask; i++) {
+        for (i = 0; i <= hash->mask; ++i) {
             HashBucket *b = hash->bi[i];
 
             while (b) {
@@ -579,7 +579,7 @@
         if (hash) {
             UINTVAL i;
 
-            for (i = 0; i <= hash->mask; i++) {
+            for (i = 0; i <= hash->mask; ++i) {
                 HashBucket *b = hash->bi[i];
 
                 while (b) {
@@ -617,7 +617,7 @@
         if (hash) {
             UINTVAL i;
 
-            for (i = 0; i <= hash->mask; i++) {
+            for (i = 0; i <= hash->mask; ++i) {
                 HashBucket *b = hash->bi[i];
 
                 while (b) {
@@ -1019,7 +1019,7 @@
         GET_ATTR_positionals(INTERP, SELF, cells);
         retval = autobox_pmc(INTERP, &cells[0]);
 
-        for (i = 1; i < size; i++)
+        for (i = 1; i < size; ++i)
             cells[i - 1] = cells[i];
 
         SET_ATTR_num_positionals(INTERP, SELF, size - 1);
@@ -1040,7 +1040,7 @@
         GET_ATTR_positionals(INTERP, SELF, cells);
         retval = autobox_string(INTERP, &cells[0]);
 
-        for (i = 1; i < size; i++)
+        for (i = 1; i < size; ++i)
             cells[i - 1] = cells[i];
 
         SET_ATTR_num_positionals(INTERP, SELF, size - 1);

Modified: trunk/src/pmc/class.pmc
==============================================================================
--- trunk/src/pmc/class.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/class.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -208,7 +208,7 @@
         /* Insert into hash, along with index. */
         VTABLE_set_integer_keyed_str(interp, attrib_index, full_key, cur_index);
         VTABLE_set_integer_keyed_str(interp, class_cache, attrib_name, cur_index);
-        cur_index++;
+        ++cur_index;
     }
 
     return cur_index;
@@ -228,7 +228,7 @@
     int                  i;
 
     /* Go over the list of all parents to construct the attribute index. */
-    for (i = 0; i < num_classes; i++) {
+    for (i = 0; i < num_classes; ++i) {
        /* Get the class and check that it respects the standard class interface
         * (if not we don't know how it stores its attributes, so we'll have to
         * delegate the lookup). */
@@ -352,7 +352,7 @@
         const int  parent_count = VTABLE_elements(interp, parent_list);
         int i;
 
-        for (i = 0; i < parent_count; i++)
+        for (i = 0; i < parent_count; ++i)
             VTABLE_add_parent(interp, self,
                 VTABLE_get_pmc_keyed_int(interp, parent_list, i));
     }
@@ -365,7 +365,7 @@
         const int   role_count = VTABLE_elements(interp, role_list);
         int i;
 
-        for (i = 0; i < role_count; i++)
+        for (i = 0; i < role_count; ++i)
             VTABLE_add_role(interp, self,
                 VTABLE_get_pmc_keyed_int(interp, role_list, i));
     }
@@ -378,7 +378,7 @@
         const int   attrib_count    = VTABLE_elements(interp, attrs_name_list);
         int i;
 
-        for (i = 0; i < attrib_count; i++) {
+        for (i = 0; i < attrib_count; ++i) {
             STRING * const attr_name = VTABLE_get_string_keyed_int(interp,
                 attrs_name_list, i);
             VTABLE_add_attribute(interp, self, attr_name, PMCNULL);
@@ -889,7 +889,7 @@
 
         /* iterate over all direct parents, check whether this class already has
          * the parent being added. */
-        for (index = 0; index < parent_count; index++) {
+        for (index = 0; index < parent_count; ++index) {
             /* get the next parent */
             PMC * const current_parent = VTABLE_get_pmc_keyed_int(INTERP,
                                       _class->parents, index);
@@ -907,7 +907,7 @@
         /* Check that none of the parents is self */
         parent_count = VTABLE_elements(INTERP, PARROT_CLASS(parent)->all_parents);
 
-        for (index = 0; index < parent_count; index++) {
+        for (index = 0; index < parent_count; ++index) {
             /* get the next parent */
             PMC * const current_parent = VTABLE_get_pmc_keyed_int(INTERP,
                 PARROT_CLASS(parent)->all_parents, index);
@@ -955,7 +955,7 @@
         parent_count = VTABLE_elements(INTERP, _class->parents);
 
         /* iterate over all direct parents, looking for the parent to remove */
-        for (index = 0; index < parent_count; index++) {
+        for (index = 0; index < parent_count; ++index) {
             /* get the next parent */
             PMC * const current_parent = VTABLE_get_pmc_keyed_int(INTERP,
                                       _class->parents, index);
@@ -1237,7 +1237,7 @@
             /* don't use HLL mappings for internal-only data */
             Parrot_pcc_set_HLL(INTERP, CURRENT_CONTEXT(INTERP), 0);
 
-            for (i = 0; i < resolve_count; i++) {
+            for (i = 0; i < resolve_count; ++i) {
                 STRING * const check_meth =
                     VTABLE_get_string_keyed_int(INTERP, _class->resolve_method, i);
                 if (!VTABLE_exists_keyed_str(INTERP, _class->methods, check_meth))
@@ -1258,7 +1258,7 @@
              * flag stating so. */
             mro_length = VTABLE_elements(INTERP, _class->all_parents);
 
-            for (i = 0; i < mro_length; i++) {
+            for (i = 0; i < mro_length; ++i) {
                 PMC * const class_check = VTABLE_get_pmc_keyed_int(INTERP,
                     _class->all_parents, i);
                 if (class_check->vtable->base_type != enum_class_Class) {
@@ -1368,7 +1368,7 @@
          * for 'isa' on the original comparison. */
         num_classes = VTABLE_elements(INTERP, _class->parents);
 
-        for (i = 0; i < num_classes; i++) {
+        for (i = 0; i < num_classes; ++i) {
             PMC * const cur_class = VTABLE_get_pmc_keyed_int(INTERP,
                     _class->parents, i);
 
@@ -1426,7 +1426,7 @@
 
         count = VTABLE_elements(INTERP, role_list);
 
-        for (i = 0; i < count; i++) {
+        for (i = 0; i < count; ++i) {
             PMC * const role = VTABLE_get_pmc_keyed_int(INTERP, role_list, i);
 
             if (VTABLE_does(INTERP, role, role_name))
@@ -1437,7 +1437,7 @@
          * for 'does' on the original comparison. */
         count = VTABLE_elements(INTERP, _class->parents);
 
-        for (i = 0; i < count; i++) {
+        for (i = 0; i < count; ++i) {
             PMC * const cur_class = VTABLE_get_pmc_keyed_int(INTERP,
                     _class->parents, i);
 
@@ -1467,7 +1467,7 @@
 
         role_count = VTABLE_elements(INTERP, role_list);
 
-        for (i = 0; i < role_count; i++) {
+        for (i = 0; i < role_count; ++i) {
             PMC    * const test_role = VTABLE_get_pmc_keyed_int(INTERP, role_list, i);
             if (VTABLE_does_pmc(INTERP, test_role, role))
                 return 1;
@@ -1477,7 +1477,7 @@
          * for 'does' on the original comparison. */
         count = VTABLE_elements(INTERP, _class->parents);
 
-        for (i = 0; i < count; i++) {
+        for (i = 0; i < count; ++i) {
             PMC * const cur_class = VTABLE_get_pmc_keyed_int(INTERP,
                     _class->parents, i);
 
@@ -1851,7 +1851,7 @@
         /* Walk and search. One day, we'll use the cache first. */
         const int num_classes = VTABLE_elements(INTERP, _class->all_parents);
 
-        for (i = 0; i < num_classes; i++) {
+        for (i = 0; i < num_classes; ++i) {
             /* Get the class and see if it has the method. */
             PMC * const cur_class =
                 VTABLE_get_pmc_keyed_int(INTERP, _class->all_parents, i);
@@ -1941,7 +1941,7 @@
             const int resolve_count = VTABLE_elements(INTERP, _class->resolve_method);
             int i;
 
-            for (i = 0; i < resolve_count; i++) {
+            for (i = 0; i < resolve_count; ++i) {
                 STRING * const meth_name = VTABLE_get_string_keyed_int(INTERP,
                     _class->resolve_method, i);
                 VTABLE_push_string(INTERP, exclude_method, meth_name);

Modified: trunk/src/pmc/codestring.pmc
==============================================================================
--- trunk/src/pmc/codestring.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/codestring.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -195,7 +195,7 @@
         jpos = Parrot_str_find_cclass(INTERP, enum_cclass_newline,
                                       str, 0, eos);
         while (jpos < eos) {
-            jpos++;
+            ++jpos;
             /* add the start of line position */
             VTABLE_push_integer(INTERP, linepos, jpos);
 
@@ -203,7 +203,7 @@
             if (jpos < eos
             && string_ord(INTERP, str, jpos - 1)     == 13
             && string_ord(INTERP, str, jpos)         == 10) {
-                jpos++;
+                ++jpos;
             }
             /* search for the next newline */
             jpos = Parrot_str_find_cclass(INTERP, enum_cclass_newline,
@@ -220,7 +220,7 @@
     count = VTABLE_elements(INTERP, linepos);
     while (line < count
           && VTABLE_get_integer_keyed_int(INTERP, linepos, line) <= pos)
-        line++;
+        ++line;
 
     RETURN(INTVAL line);
   }
@@ -245,7 +245,7 @@
     STRING * const counter_as_string = Parrot_str_from_int(INTERP, counter);
     UNUSED(SELF);
 
-    counter++;
+    ++counter;
 
     if (!has_fmt) {
         RETURN(STRING *counter_as_string);
@@ -347,7 +347,7 @@
     STRING *       prefix        = NULL;
     STRING *       out           = open_bracket;
 
-    for (index = 0; index < elements; index++) {
+    for (index = 0; index < elements; ++index) {
         PMC * const P0 = VTABLE_get_pmc_keyed_int(INTERP, args, index);
 
         if (!PMC_IS_NULL(P0)) {
@@ -355,7 +355,7 @@
                 const INTVAL elements2 = VTABLE_elements(INTERP, P0);
                 INTVAL index2;
 
-                for (index2 = 0; index2 < elements2; index2++) {
+                for (index2 = 0; index2 < elements2; ++index2) {
                     STRING *S0   = VTABLE_get_string_keyed_int(INTERP, P0, index2);
                     (STRING *S0) = PCCINVOKE(INTERP, SELF, "escape", STRING *S0);
                     if (prefix)

Modified: trunk/src/pmc/complex.pmc
==============================================================================
--- trunk/src/pmc/complex.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/complex.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -100,26 +100,26 @@
 
     if (*t == '-') {
         /* first number is negative */
-        t++;
+        ++t;
         first_num_minus = 1;
 
         /* allow for an optional space */
         if (*t == ' ')
-            t++;
+            ++t;
         first_num_offset = t;
     }
 
     /* skip digits */
     while (*t >= '0' && *t <= '9')
-        t++;
+        ++t;
 
     if (*t == '.') {
         /* this number has a decimal point */
-        t++;
+        ++t;
 
         /* skip digits */
         while (*t >= '0' && *t <= '9')
-            t++;
+            ++t;
     }
 
     /* save the length of the real part */
@@ -145,32 +145,32 @@
     else {
         /* skip an optional space */
         if (*t == ' ')
-            t++;
+            ++t;
 
         /* expect "+" or "-" and the imaginary part */
         if (*t == '+' || *t == '-') {
             /* save the sign */
             second_num_minus = (*t == '-');
-            t++;
+            ++t;
 
             /* skip another optional space */
             if (*t == ' ')
-                t++;
+                ++t;
 
             /* save the beginning of the imaginary part */
             second_num_offset = t;
 
             /* skip digits */
             while (*t >= '0' && *t <= '9')
-                t++;
+                ++t;
 
             if (*t == '.') {
                 /* this number has a decimal point */
-                t++;
+                ++t;
 
                 /* skip digits */
                 while (*t >= '0' && *t <= '9')
-                    t++;
+                    ++t;
             }
 
             /* save the length of the imaginary part */
@@ -178,7 +178,7 @@
 
             /* allow for one more optional space */
             if (*t == ' ')
-                t++;
+                ++t;
 
             /* verify that the string ends properly */
             if ((*t != 'i' && *t != 'j') || (*(t+1) != 0)) {

Modified: trunk/src/pmc/env.pmc
==============================================================================
--- trunk/src/pmc/env.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/env.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -97,7 +97,7 @@
         INTVAL rv = 0;
 
         while (environ[rv] != NULL)
-            rv++;
+            ++rv;
 
         return rv;
     }

Modified: trunk/src/pmc/eval.pmc
==============================================================================
--- trunk/src/pmc/eval.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/eval.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -73,7 +73,7 @@
     if (!ct)
         return;
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         PackFile_FixupEntry * const e = ft->fixups + i;
 
         if (e->type == enum_fixup_sub) {
@@ -112,7 +112,7 @@
     if (!ct)
         return PMCNULL;
 
-    for (i = n = 0; i < ft->fixup_count; i++) {
+    for (i = n = 0; i < ft->fixup_count; ++i) {
         const PackFile_FixupEntry * const e = ft->fixups + i;
 
         if (e->type == enum_fixup_sub) {
@@ -151,7 +151,7 @@
     if (!ct)
         return;
 
-    for (i = 0; i < ft->fixup_count; i++) {
+    for (i = 0; i < ft->fixup_count; ++i) {
         const PackFile_FixupEntry * const e = ft->fixups + i;
 
         if (e->type == enum_fixup_sub) {
@@ -426,11 +426,11 @@
         if (!ft)
             return 0;
 
-        for (i = n = 0; i < ft->fixup_count; i++) {
+        for (i = n = 0; i < ft->fixup_count; ++i) {
             const PackFile_FixupEntry * const e = ft->fixups + i;
 
             if (e->type == enum_fixup_sub)
-                n++;
+                ++n;
         }
 
         return n;

Modified: trunk/src/pmc/exceptionhandler.pmc
==============================================================================
--- trunk/src/pmc/exceptionhandler.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/exceptionhandler.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -185,7 +185,7 @@
                 const INTVAL type  = VTABLE_get_integer_keyed_str(interp, exception, CONST_STRING(interp, "type"));
                 INTVAL i;
 
-                for (i = 0; i < elems; i++) {
+                for (i = 0; i < elems; ++i) {
                     INTVAL handled_type = VTABLE_get_integer_keyed_int(interp,
                             handled_types, i);
                     if (handled_type == type)
@@ -199,7 +199,7 @@
                 const INTVAL type  = VTABLE_get_integer_keyed_str(interp, exception, CONST_STRING(interp, "type"));
                 INTVAL i;
 
-                for (i = 0; i < elems; i++) {
+                for (i = 0; i < elems; ++i) {
                     const INTVAL handled_type = VTABLE_get_integer_keyed_int(interp,
                             handled_types_except, i);
                     if (handled_type == type)

Modified: trunk/src/pmc/exporter.pmc
==============================================================================
--- trunk/src/pmc/exporter.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/exporter.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -256,7 +256,7 @@
                 if (n == 0)
                     temp_globals = PMCNULL;
 
-                for (i = 0; i < n; i++) {
+                for (i = 0; i < n; ++i) {
                     STRING * const item = VTABLE_get_string_keyed_int(interp, glb_array, i);
                     VTABLE_set_string_keyed_str(interp, temp_globals, item, s_empty);
                 }

Modified: trunk/src/pmc/fixedbooleanarray.pmc
==============================================================================
--- trunk/src/pmc/fixedbooleanarray.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/fixedbooleanarray.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -281,7 +281,7 @@
         zero = CONST_STRING(INTERP, "0");
         one  = CONST_STRING(INTERP, "1");
 
-        for (i = 0; i < elems; i++) {
+        for (i = 0; i < elems; ++i) {
             if (SELF.get_integer_keyed_int((INTVAL)i))
                 str = Parrot_str_concat(INTERP, str, one);
             else

Modified: trunk/src/pmc/fixedpmcarray.pmc
==============================================================================
--- trunk/src/pmc/fixedpmcarray.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/fixedpmcarray.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -403,7 +403,7 @@
         PMC_size(SELF) = size;
         data           = mem_gc_allocate_n_typed(INTERP, size, PMC *);
 
-        for (i = 0; i < size; i++)
+        for (i = 0; i < size; ++i)
             data[i] = PMCNULL;
 
         PMC_array(SELF) = data;
@@ -426,7 +426,7 @@
         size            = PMC_size(SELF) = VTABLE_elements(INTERP, value);
         PMC_array(SELF) = mem_gc_allocate_n_typed(INTERP, size, PMC *);
 
-        for (i = 0; i < size; i++)
+        for (i = 0; i < size; ++i)
             (PMC_array(SELF))[i] = VTABLE_get_pmc_keyed_int(INTERP, value, i);
 
         PObj_custom_mark_destroy_SETALL(SELF);

Modified: trunk/src/pmc/fixedstringarray.pmc
==============================================================================
--- trunk/src/pmc/fixedstringarray.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/fixedstringarray.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -141,7 +141,7 @@
             UINTVAL size, i;
             GET_ATTR_size(INTERP, SELF, size);
 
-            for (i = 0; i < size; i++) {
+            for (i = 0; i < size; ++i) {
                 Parrot_gc_mark_STRING_alive(INTERP, str_array[i]);
             }
         }

Modified: trunk/src/pmc/float.pmc
==============================================================================
--- trunk/src/pmc/float.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/float.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -300,7 +300,7 @@
     VTABLE void increment() {
         FLOATVAL fv;
         GET_ATTR_fv(INTERP, SELF, fv);
-        fv++;
+        ++fv;
         SET_ATTR_fv(INTERP, SELF, fv);
     }
 

Modified: trunk/src/pmc/hashiterator.pmc
==============================================================================
--- trunk/src/pmc/hashiterator.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/hashiterator.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -90,7 +90,7 @@
         bucket = attrs->parrot_hash->bi[attrs->pos++];
     }
     attrs->bucket = bucket;
-    attrs->elements--;
+    --attrs->elements;
 
     return;
 }

Modified: trunk/src/pmc/imageio.pmc
==============================================================================
--- trunk/src/pmc/imageio.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/imageio.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -303,7 +303,7 @@
             packid_type = enum_PackID_seen;
         }
         else {
-            PARROT_IMAGEIO(info)->id++; /* next id to freeze */
+            ++PARROT_IMAGEIO(info)->id; /* next id to freeze */
             id = PARROT_IMAGEIO(info)->id;
             packid_type = enum_PackID_normal;
         }

Modified: trunk/src/pmc/namespace.pmc
==============================================================================
--- trunk/src/pmc/namespace.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/namespace.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -532,7 +532,7 @@
                     break;
                 }
                 ns = Parrot_get_namespace_keyed_str(INTERP, ns, name);
-                i++;
+                ++i;
             }
             return ns;
         }
@@ -818,7 +818,7 @@
             Parrot_NameSpace_attributes *nsinfo = PARROT_NAMESPACE(ns);
             VTABLE_unshift_string(INTERP, ar, nsinfo->name);
             ns = nsinfo->parent;
-            elements++;
+            ++elements;
         }
 
         /* remove the NULL string of the namespace root */

Modified: trunk/src/pmc/nci.pmc
==============================================================================
--- trunk/src/pmc/nci.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/nci.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -64,7 +64,7 @@
     size_t  j            = 0;
     size_t  i;
 
-    for (i = 1; i < sig_length; i++) {
+    for (i = 1; i < sig_length; ++i) {
         const INTVAL c = Parrot_str_indexed(interp, sig, i);
 
         switch (c) {

Modified: trunk/src/pmc/orderedhashiterator.pmc
==============================================================================
--- trunk/src/pmc/orderedhashiterator.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/orderedhashiterator.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -183,8 +183,8 @@
                 ORDERED_HASH_ITEM_KEY);
         attrs->next_entry = VTABLE_get_pmc_keyed_int(INTERP, attrs->next_entry,
                 ORDERED_HASH_ITEM_NEXT);
-        attrs->pos++;
-        attrs->elements--;
+        ++attrs->pos;
+        --attrs->elements;
 
         return ret;
     }

Modified: trunk/src/pmc/pmcproxy.pmc
==============================================================================
--- trunk/src/pmc/pmcproxy.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/pmcproxy.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -136,7 +136,7 @@
 
         /* Build MRO (skip ourself). */
         mro_length = VTABLE_elements(interp, interp->vtables[type_num]->mro);
-        for (i = 1; i < mro_length; i++) {
+        for (i = 1; i < mro_length; ++i) {
             PMC    *pclass = VTABLE_get_pmc_keyed_int(interp, interp->vtables[type_num]->mro, i);
             PMC    *cns    = pclass->vtable->_namespace;
             STRING *cname  = pclass->vtable->whoami;
@@ -260,7 +260,7 @@
          * for 'isa' on the original comparison. */
         num_classes = VTABLE_elements(interp, _proxy->parents);
 
-        for (i = 0; i < num_classes; i++) {
+        for (i = 0; i < num_classes; ++i) {
             PMC * const cur_class = VTABLE_get_pmc_keyed_int(interp,
                 _proxy->parents, i);
 

Modified: trunk/src/pmc/resizablepmcarray.pmc
==============================================================================
--- trunk/src/pmc/resizablepmcarray.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/resizablepmcarray.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -99,7 +99,7 @@
             PMC_array(SELF) = mem_gc_realloc_n_typed_zeroed(INTERP,
                     PMC_array(SELF), cur, i, PMC *);
 
-            for (; i < cur; i++) {
+            for (; i < cur; ++i) {
                 (PMC_array(SELF))[i] = PMCNULL;
             }
 
@@ -703,7 +703,7 @@
         /* shrink the array */
         if (shift < 0) {
             /* start at offset so we don't overwrite values we'll need */
-            for (i = offset + count; i < length; i++)
+            for (i = offset + count; i < length; ++i)
                 VTABLE_set_pmc_keyed_int(INTERP, SELF, i + shift,
                     VTABLE_get_pmc_keyed_int(INTERP, SELF, i));
 
@@ -721,7 +721,7 @@
         }
 
         /* copy the new values */
-        for (i = 0; i < elems; i++)
+        for (i = 0; i < elems; ++i)
             VTABLE_set_pmc_keyed_int(INTERP, SELF, i + offset,
                 VTABLE_get_pmc_keyed_int(INTERP, value, i));
     }

Modified: trunk/src/pmc/resizablestringarray.pmc
==============================================================================
--- trunk/src/pmc/resizablestringarray.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/resizablestringarray.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -225,7 +225,7 @@
             GET_ATTR_size(interp, SELF, old_size);
             if (new_size > old_size) {
                 INTVAL i;
-                for (i = old_size; i < new_size; i++)
+                for (i = old_size; i < new_size; ++i)
                     str_array[i] = NULL;
             }
 
@@ -249,7 +249,7 @@
                             cur, resize_threshold, STRING*));
             GET_ATTR_str_array(INTERP, SELF, str_array);
 
-            for (; i < cur; i++)
+            for (; i < cur; ++i)
                 str_array[i] = NULL;
 
             SET_ATTR_size(INTERP, SELF, new_size);
@@ -605,7 +605,7 @@
         /* shrink the array */
         if (shift < 0) {
             /* start at offset so we don't overwrite values we'll need */
-            for (i = offset+count; i < length; i++)
+            for (i = offset+count; i < length; ++i)
                 VTABLE_set_pmc_keyed_int(INTERP, SELF, i + shift,
                     VTABLE_get_pmc_keyed_int(INTERP, SELF, i));
 
@@ -623,7 +623,7 @@
         }
 
         /* copy the new values */
-        for (i = 0; i < elems; i++)
+        for (i = 0; i < elems; ++i)
             VTABLE_set_pmc_keyed_int(INTERP, SELF, i + offset,
                 VTABLE_get_pmc_keyed_int(INTERP, value, i));
     }

Modified: trunk/src/pmc/role.pmc
==============================================================================
--- trunk/src/pmc/role.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/role.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -163,7 +163,7 @@
         PMC    * const role_list = VTABLE_get_pmc_keyed_str(interp, info, roles_str);
         const int role_count     = VTABLE_elements(interp, role_list);
 
-        for (i = 0; i < role_count; i++) {
+        for (i = 0; i < role_count; ++i) {
             PMC * const cur_role = VTABLE_get_pmc_keyed_int(interp, role_list, i);
             VTABLE_add_role(interp, self, cur_role);
         }
@@ -177,7 +177,7 @@
 
         const int attrib_count = VTABLE_elements(interp, attrib_name_list);
 
-        for (i = 0; i < attrib_count; i++) {
+        for (i = 0; i < attrib_count; ++i) {
             STRING * const attrib_name = VTABLE_get_string_keyed_int(interp,
                 attrib_name_list, i);
             VTABLE_add_attribute(interp, self, attrib_name, PMCNULL);
@@ -536,7 +536,7 @@
             return 1;
 
         count = VTABLE_elements(interp, role->roles);
-        for (i = 0; i < count; i++) {
+        for (i = 0; i < count; ++i) {
             PMC *cur_role = VTABLE_get_pmc_keyed_int(interp, role->roles, i);
             if (VTABLE_does(interp, cur_role, role_name))
                 return 1;
@@ -563,7 +563,7 @@
             return 1;
 
         count = VTABLE_elements(interp, this_role->roles);
-        for (i = 0; i < count; i++) {
+        for (i = 0; i < count; ++i) {
             PMC *cur_role = VTABLE_get_pmc_keyed_int(interp, this_role->roles, i);
             if (VTABLE_does_pmc(interp, cur_role, role))
                 return 1;

Modified: trunk/src/pmc/scheduler.pmc
==============================================================================
--- trunk/src/pmc/scheduler.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/scheduler.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -523,7 +523,7 @@
                 &&   handler->vtable->base_type == enum_class_ExceptionHandler)
                 || (Parrot_str_equal(INTERP, type, event)
                 &&  handler->vtable->base_type == enum_class_EventHandler))
-                        count++;
+                        ++count;
             }
         }
 

Modified: trunk/src/pmc/string.pmc
==============================================================================
--- trunk/src/pmc/string.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/string.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -567,7 +567,7 @@
                 break;
 
             i = i * base + dig;
-            j++;
+            ++j;
         }
 
         if (j < len) {

Modified: trunk/src/pmc/sub.pmc
==============================================================================
--- trunk/src/pmc/sub.pmc	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc/sub.pmc	Fri Apr 30 08:27:15 2010	(r46192)
@@ -857,7 +857,7 @@
 
                 ASSERT_SIG_PMC(sig);
 
-                for (i = 0; i < sig_length; i++) {
+                for (i = 0; i < sig_length; ++i) {
                     int sig_item = VTABLE_get_integer_keyed_int(INTERP, sig, i);;
                     if (PARROT_ARG_SLURPY_ARRAY_ISSET(sig_item)){
                         if (PARROT_ARG_NAME_ISSET(sig_item))
@@ -866,18 +866,18 @@
                             sub->arg_info->pos_slurpy = 1;
                     }
                     else if (PARROT_ARG_NAME_ISSET(sig_item)) {
-                        i++;
+                        ++i;
                         sig_item = VTABLE_get_integer_keyed_int(INTERP, sig, i);;
                         if (PARROT_ARG_OPTIONAL_ISSET(sig_item))
-                            sub->arg_info->named_optional++;
+                            ++sub->arg_info->named_optional;
                         else
-                            sub->arg_info->named_required++;
+                            ++sub->arg_info->named_required;
                     }
                     else if (!PARROT_ARG_OPT_FLAG_ISSET(sig_item)) {
                         if (PARROT_ARG_OPTIONAL_ISSET(sig_item))
-                            sub->arg_info->pos_optional++;
+                            ++sub->arg_info->pos_optional;
                         else
-                            sub->arg_info->pos_required++;
+                            ++sub->arg_info->pos_required;
                     }
                 }
             }

Modified: trunk/src/pmc_freeze.c
==============================================================================
--- trunk/src/pmc_freeze.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/pmc_freeze.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -206,7 +206,7 @@
     PMC * const todo    = VTABLE_get_iter(interp, info);
 
     /* can't cache upper limit, visit may append items */
-    for (i = 0; i < VTABLE_elements(interp, todo); i++) {
+    for (i = 0; i < VTABLE_elements(interp, todo); ++i) {
         PMC * const current = VTABLE_get_pmc_keyed_int(interp, todo, i);
         if (!current)
             Parrot_ex_throw_from_c_args(interp, NULL, 1,

Modified: trunk/src/runcore/cores.c
==============================================================================
--- trunk/src/runcore/cores.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/runcore/cores.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -73,7 +73,7 @@
 structure to execute opcodes. Here's a brief example of how this
 architecture works:
 
-  for( ; ; current_opcode++) {
+  for( ; ; ++current_opcode) {
       switch(*current_opcode) {
           case opcode_1:
               ...

Modified: trunk/src/runcore/profiling.c
==============================================================================
--- trunk/src/runcore/profiling.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/runcore/profiling.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -334,7 +334,7 @@
         preop_ctx->current_pc = pc;
         preop_pc              = pc;
 
-        runcore->level++;
+        ++runcore->level;
         Profiling_exit_check_CLEAR(runcore);
 
         runcore->op_start  = Parrot_hires_get_time();
@@ -375,7 +375,7 @@
                 ns_separator = Parrot_str_new(interp, ";", 1);
 
                 i = MAX_NS_DEPTH - 1;
-                for (;ns ; i--) {
+                for (;ns ; --i) {
                     if (i < 0) {
                         /* should probably warn about truncated namespace here */
                         break;
@@ -384,9 +384,8 @@
                     GETATTR_NameSpace_parent(interp, ns, ns);
                 }
 
-                i++;
-                i++; /* the root namespace has an empty name, so ignore it */
-                for (;i < MAX_NS_DEPTH; i++) {
+                i += 2; /* the root namespace has an empty name, so ignore it */
+                for (;i < MAX_NS_DEPTH; ++i) {
                     full_ns = Parrot_str_concat(interp, full_ns, ns_names[i]);
                     full_ns = Parrot_str_concat(interp, full_ns, ns_separator);
                 }
@@ -511,7 +510,7 @@
     pprof_data[PPROF_DATA_OPNAME] = (PPROF_DATA) "noop";
     runcore->output_fn(runcore, pprof_data, PPROF_LINE_OP);
 
-    runcore->runloop_count++;
+    ++runcore->runloop_count;
 }
 
 /*

Modified: trunk/src/runcore/trace.c
==============================================================================
--- trunk/src/runcore/trace.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/runcore/trace.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -316,7 +316,7 @@
         INTVAL i;
         len += Parrot_io_eprintf(debugger, " ");
         /* pass 1 print arguments */
-        for (i = s; i < n; i++) {
+        for (i = s; i < n; ++i) {
             const opcode_t o = pc[i];
 
             if (i < info->op_count)
@@ -415,7 +415,7 @@
             Parrot_io_eprintf(debugger, "\t");
 
         /* pass 2 print argument details if needed */
-        for (i = 1; i < n; i++) {
+        for (i = 1; i < n; ++i) {
             const opcode_t o = pc[i];
             if (i < info->op_count)
                 type = info->types[i - 1];

Modified: trunk/src/scheduler.c
==============================================================================
--- trunk/src/scheduler.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/scheduler.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -445,7 +445,7 @@
         LOCK(sched_struct->msg_lock);
         /* Search the task index for GC suspend tasks */
         num_tasks = VTABLE_elements(interp, sched_struct->messages);
-        for (index = 0; index < num_tasks; index++) {
+        for (index = 0; index < num_tasks; ++index) {
             PMC *message = VTABLE_get_pmc_keyed_int(interp, sched_struct->messages, index);
             if (!PMC_IS_NULL(message)
             &&   Parrot_str_equal(interp, VTABLE_get_string(interp, message),
@@ -612,11 +612,11 @@
                 switch (htype) {
                   case Hexception:
                     if (VTABLE_isa(interp, handler, handler_name))
-                        count++;
+                        ++count;
                     break;
                   case Hevent:
                     if (handler->vtable->base_type == enum_class_EventHandler)
-                        count++;
+                        ++count;
                     break;
                   default:
                     break;
@@ -1069,7 +1069,7 @@
 
     /* Sweep the wait list for completed timers */
     num_tasks = VTABLE_elements(interp, sched_struct->wait_index);
-    for (index = 0; index < num_tasks; index++) {
+    for (index = 0; index < num_tasks; ++index) {
         INTVAL tid = VTABLE_get_integer_keyed_int(interp, sched_struct->wait_index, index);
         if (tid > 0) {
             PMC *task = VTABLE_get_pmc_keyed_int(interp, sched_struct->task_list, tid);

Modified: trunk/src/spf_render.c
==============================================================================
--- trunk/src/spf_render.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/spf_render.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -144,12 +144,12 @@
             if (info->flags & FLAG_PLUS) {
                 STRING * const cs = CONST_STRING(interp, "+");
                 str = Parrot_str_concat(interp, cs, str);
-                len++;
+                ++len;
             }
             else if (info->flags & FLAG_SPACE) {
                 STRING * const cs = CONST_STRING(interp, " ");
                 str = Parrot_str_concat(interp, cs, str);
-                len++;
+                ++len;
             }
         }
 
@@ -340,7 +340,7 @@
     STRING *substr = NULL;
     char tc[PARROT_SPRINTF_BUFFER_SIZE];
 
-    for (i = 0; i < pat_len; i++) {
+    for (i = 0; i < pat_len; ++i) {
         if (string_ord(interp, pat, i) == '%') {        /* % */
             if (len) {
                 substr = Parrot_str_substr(interp, pat, old, len);
@@ -352,9 +352,9 @@
             if (string_ord(interp, pat, i + 1) == '%') {
                 /* skip this one, make next the first char
                  * of literal sequence, starting at old */
-                i++;
-                old++;
-                len++;
+                ++i;
+                ++old;
+                ++len;
                 continue;
             }
             else {
@@ -459,7 +459,7 @@
  *  set flags--the last does all the work.
  */
 
-                for (i++; i < pat_len && info.phase != PHASE_DONE; i++) {
+                for (++i; i < pat_len && info.phase != PHASE_DONE; ++i) {
                     const INTVAL ch = string_ord(interp, pat, i);
 
                     switch (info.phase) {
@@ -783,7 +783,7 @@
                              || ch == 'e' || ch == 'E') {
                                 const size_t tclen = strlen(tc);
                                 size_t j;
-                                for (j = 0; j < tclen; j++) {
+                                for (j = 0; j < tclen; ++j) {
                                     if ((tc[j] == 'e' || tc[j] == 'E')
                                         && (tc[j+1] == '+' || tc[j+1] == '-')
                                         && tc[j+2] == '0'
@@ -831,7 +831,7 @@
                                 STRING * const string = (VTABLE_get_repr(interp, tmp));
                                 STRING * const ts     = handle_flags(interp, &info,
                                                     string, 0, NULL);
-                                obj->index++;
+                                ++obj->index;
 
                                 targ = Parrot_str_concat(interp, targ, ts);
                                 break;
@@ -882,10 +882,10 @@
             }
 
             old = i;
-            i--;
+            --i;
         }
         else {
-            len++;
+            ++len;
         }
     }
     if (len) {

Modified: trunk/src/spf_vtable.c
==============================================================================
--- trunk/src/spf_vtable.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/spf_vtable.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -450,7 +450,7 @@
             ((PMC *)obj->data),
             (obj->index));
 
-    obj->index++;
+    ++obj->index;
     s = VTABLE_get_string(interp, tmp);
     /* XXX Parrot_str_copy like below? + adjusting bufused */
     return Parrot_str_substr(interp, s, 0, 1);
@@ -473,13 +473,12 @@
 getint_pmc(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 {
     ASSERT_ARGS(getint_pmc)
-    HUGEINTVAL ret;
+
     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
             ((PMC *)obj->data),
-            (obj->index));
+            (obj->index++));
 
-    obj->index++;
-    ret = VTABLE_get_integer(interp, tmp);
+    HUGEINTVAL ret  = VTABLE_get_integer(interp, tmp);
 
     switch (size) {
       case SIZE_SHORT:
@@ -513,13 +512,12 @@
 getuint_pmc(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 {
     ASSERT_ARGS(getuint_pmc)
-    UHUGEINTVAL ret;
+
     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
             ((PMC *)obj->data),
-            (obj->index));
+            (obj->index++));
 
-    obj->index++;
-    ret = (UINTVAL)VTABLE_get_integer(interp, tmp);
+    UHUGEINTVAL ret = (UINTVAL)VTABLE_get_integer(interp, tmp);
 
     switch (size) {
       case SIZE_SHORT:
@@ -553,13 +551,11 @@
 getfloat_pmc(PARROT_INTERP, INTVAL size, ARGIN(SPRINTF_OBJ *obj))
 {
     ASSERT_ARGS(getfloat_pmc)
-    HUGEFLOATVAL ret;
-    PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
+    PMC * const tmp  = VTABLE_get_pmc_keyed_int(interp,
             ((PMC *)obj->data),
-            (obj->index));
+            (obj->index++));
 
-    obj->index++;
-    ret = (HUGEFLOATVAL)(VTABLE_get_number(interp, tmp));
+    HUGEFLOATVAL ret = (HUGEFLOATVAL)(VTABLE_get_number(interp, tmp));
 
     switch (size) {
     case SIZE_SHORT:
@@ -591,14 +587,13 @@
 getstring_pmc(PARROT_INTERP, SHIM(INTVAL size), ARGIN(SPRINTF_OBJ *obj))
 {
     ASSERT_ARGS(getstring_pmc)
-    STRING *s;
+
     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
             ((PMC *)obj->data),
-            (obj->index));
+            (obj->index++));
 
-    obj->index++;
-    s = (STRING *)(VTABLE_get_string(interp, tmp));
-    return s;
+    STRING * const str = (STRING *)(VTABLE_get_string(interp, tmp));
+    return str;
 }
 
 /*
@@ -619,11 +614,9 @@
 {
     ASSERT_ARGS(getptr_pmc)
     PMC * const tmp = VTABLE_get_pmc_keyed_int(interp,
-            ((PMC *)obj->data), (obj->index));
+            ((PMC *)obj->data), (obj->index++));
     const INTVAL i  = VTABLE_get_integer(interp, tmp);
 
-    obj->index++;
-
     /* XXX correct? */
     return (void *)i;
 }

Modified: trunk/src/string/api.c
==============================================================================
--- trunk/src/string/api.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/api.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -1022,7 +1022,7 @@
         UINTVAL i;
         char *             destpos = dest->strstart;
         const char * const srcpos  = s->strstart;
-        for (i = 0; i < num; i++) {
+        for (i = 0; i < num; ++i) {
             mem_sys_memcopy(destpos, srcpos, length);
             destpos += length;
         }
@@ -2014,7 +2014,7 @@
                 d = d*10 + (c-'0');
                 if (d >= max_safe)
                     d_is_safe = 0;
-                d_length++;
+                ++d_length;
             }
             else if (c == 'e' || c == 'E')
                 state = parse_after_e;
@@ -2583,8 +2583,8 @@
         if (d == offs) {
             /* we did it in place - no action */
             ++d;
-            iter.bytepos++;
-            iter.charpos++;
+            ++(iter.bytepos);
+            ++(iter.charpos);
             continue;
         }
 

Modified: trunk/src/string/charset.c
==============================================================================
--- trunk/src/string/charset.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/charset.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -348,7 +348,7 @@
         all_charsets->set = mem_gc_realloc_n_typed_zeroed(interp,
                 all_charsets->set, n + 1, n, One_charset);
 
-    all_charsets->n_charsets++;
+    ++all_charsets->n_charsets;
     all_charsets->set[n].charset      = charset;
     all_charsets->set[n].n_converters = 0;
 
@@ -372,7 +372,7 @@
 {
     ASSERT_ARGS(Parrot_str_internal_register_charset_names)
     int n;
-    for (n = 0; n < all_charsets->n_charsets; n++)
+    for (n = 0; n < all_charsets->n_charsets; ++n)
         all_charsets->set[n].name =
             Parrot_str_new_constant(interp, all_charsets->set[n].charset->name);
 }

Modified: trunk/src/string/charset/ascii.c
==============================================================================
--- trunk/src/string/charset/ascii.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/charset/ascii.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -316,7 +316,7 @@
         char * const buffer = result->strstart;
         UINTVAL offset;
 
-        for (offset = 0; offset < n; offset++) {
+        for (offset = 0; offset < n; ++offset) {
             buffer[offset] = (char)toupper((unsigned char)buffer[offset]);
         }
     }
@@ -346,7 +346,7 @@
         char * const buffer = result->strstart;
         UINTVAL offset;
 
-        for (offset = 0; offset < n; offset++) {
+        for (offset = 0; offset < n; ++offset) {
             buffer[offset] = (char)tolower((unsigned char)buffer[offset]);
         }
     }
@@ -379,7 +379,7 @@
         UINTVAL offset;
 
         buffer[0] = (char)toupper((unsigned char)buffer[0]);
-        for (offset = 1; offset < n; offset++) {
+        for (offset = 1; offset < n; ++offset) {
             buffer[offset] = (char)tolower((unsigned char)buffer[offset]);
         }
     }

Modified: trunk/src/string/charset/iso-8859-1.c
==============================================================================
--- trunk/src/string/charset/iso-8859-1.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/charset/iso-8859-1.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -331,7 +331,7 @@
         return result;
 
     buffer = (unsigned char *)result->strstart;
-    for (offset = 0; offset < result->strlen; offset++) {
+    for (offset = 0; offset < result->strlen; ++offset) {
         unsigned int c = buffer[offset]; /* XXX use encoding ? */
         if (c >= 0xe0 && c != 0xf7)
             c &= ~0x20;
@@ -367,7 +367,7 @@
         return result;
 
     buffer = (unsigned char *)result->strstart;
-    for (offset = 0; offset < result->strlen; offset++) {
+    for (offset = 0; offset < result->strlen; ++offset) {
         unsigned int c = buffer[offset];
         if (c >= 0xc0 && c != 0xd7 && c <= 0xde)
             c |= 0x20;
@@ -411,7 +411,7 @@
         c = toupper((unsigned char)c);
     buffer[0] = (unsigned char)c;
 
-    for (offset = 1; offset < result->strlen; offset++) {
+    for (offset = 1; offset < result->strlen; ++offset) {
         c = buffer[offset];
         if (c >= 0xc0 && c != 0xd7 && c <= 0xde)
             c |= 0x20;

Modified: trunk/src/string/encoding.c
==============================================================================
--- trunk/src/string/encoding.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/encoding.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -327,7 +327,7 @@
     else
         all_encodings->enc = mem_gc_realloc_n_typed_zeroed(interp,
                 all_encodings->enc, n + 1, n, One_encoding);
-    all_encodings->n_encodings++;
+    ++all_encodings->n_encodings;
     all_encodings->enc[n].encoding = encoding;
 
     return 1;
@@ -351,7 +351,7 @@
 {
     ASSERT_ARGS(Parrot_str_internal_register_encoding_names)
     int n;
-    for (n = 0; n < all_encodings->n_encodings; n++)
+    for (n = 0; n < all_encodings->n_encodings; ++n)
         all_encodings->enc[n].name =
             Parrot_str_new_constant(interp, all_encodings->enc[n].encoding->name);
 }

Modified: trunk/src/string/encoding/fixed_8.c
==============================================================================
--- trunk/src/string/encoding/fixed_8.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/encoding/fixed_8.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -388,7 +388,7 @@
 {
     ASSERT_ARGS(fixed8_get_next)
     const UINTVAL c = get_byte(interp, iter->str, iter->charpos++);
-    iter->bytepos++;
+    ++iter->bytepos;
     return c;
 }
 
@@ -409,7 +409,7 @@
 {
     ASSERT_ARGS(fixed8_set_next)
     set_byte(interp, iter->str, iter->charpos++, c);
-    iter->bytepos++;
+    ++iter->bytepos;
 }
 
 /*

Modified: trunk/src/string/encoding/ucs2.c
==============================================================================
--- trunk/src/string/encoding/ucs2.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/encoding/ucs2.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -423,7 +423,7 @@
      *      iter versions
      */
     const UChar c = s[pos++];
-    i->charpos++;
+    ++i->charpos;
     i->bytepos = pos * sizeof (UChar);
     return c;
 #else
@@ -457,7 +457,7 @@
     UChar    *s = (UChar*) i->str->strstart;
     UINTVAL pos = i->bytepos / sizeof (UChar);
     s[pos++]    = (UChar)c;
-    i->charpos++;
+    ++i->charpos;
     i->bytepos = pos * sizeof (UChar);
 #else
     /* This function must never be called if compiled without ICU.

Modified: trunk/src/string/encoding/utf16.c
==============================================================================
--- trunk/src/string/encoding/utf16.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/encoding/utf16.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -485,7 +485,7 @@
      *      iter versions
      */
     U16_NEXT_UNSAFE(s, pos, c);
-    i->charpos++;
+    ++i->charpos;
     i->bytepos = pos * sizeof (UChar);
     return c;
 }
@@ -509,7 +509,7 @@
     UChar * const s = (UChar*) i->str->strstart;
     UINTVAL pos = i->bytepos / sizeof (UChar);
     U16_APPEND_UNSAFE(s, pos, c);
-    i->charpos++;
+    ++i->charpos;
     i->bytepos = pos * sizeof (UChar);
 }
 

Modified: trunk/src/string/encoding/utf8.c
==============================================================================
--- trunk/src/string/encoding/utf8.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/string/encoding/utf8.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -229,7 +229,7 @@
 
     while (u8ptr < u8end) {
         u8ptr += UTF8SKIP(u8ptr);
-        characters++;
+        ++characters;
     }
 
     if (u8ptr > u8end)
@@ -261,8 +261,8 @@
         UINTVAL count;
 
         c &= UTF8_START_MASK(len);
-        for (count = 1; count < len; count++) {
-            u8ptr++;
+        for (count = 1; count < len; ++count) {
+            ++u8ptr;
 
             if (!UTF8_IS_CONTINUATION(*u8ptr))
                 Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_MALFORMED_UTF8,
@@ -408,8 +408,8 @@
 
         c &= UTF8_START_MASK(len);
         i->bytepos += len;
-        for (len--; len; len--) {
-            u8ptr++;
+        for (--len; len; --len) {
+            ++u8ptr;
 
             if (!UTF8_IS_CONTINUATION(*u8ptr))
                 Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_MALFORMED_UTF8,
@@ -427,10 +427,10 @@
             "Malformed UTF-8 string\n");
     }
     else {
-        i->bytepos++;
+        ++i->bytepos;
     }
 
-    i->charpos++;
+    ++i->charpos;
     return c;
 }
 
@@ -457,7 +457,7 @@
     i->bytepos += (new_pos - pos);
     /* XXX possible buffer overrun exception? */
     PARROT_ASSERT(i->bytepos <= Buffer_buflen(s));
-    i->charpos++;
+    ++i->charpos;
 }
 
 /*

Modified: trunk/src/sub.c
==============================================================================
--- trunk/src/sub.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/sub.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -181,7 +181,7 @@
 
         if (!debug)
             return 0;
-        for (i = n = 0; n < sub->seg->base.size; i++) {
+        for (i = n = 0; n < sub->seg->base.size; ++i) {
             op_info_t * const op_info = &interp->op_info_table[*pc];
             opcode_t var_args = 0;
 
@@ -233,7 +233,7 @@
     base_pc            = sub->seg->base.data;
     current_annotation = pc - base_pc;
 
-    for (i = op = 0; op < debug_size; i++) {
+    for (i = op = 0; op < debug_size; ++i) {
         op_info_t * const op_info  = &interp->op_info_table[*base_pc];
         opcode_t          var_args = 0;
 

Modified: trunk/src/thread.c
==============================================================================
--- trunk/src/thread.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/thread.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -1443,7 +1443,7 @@
 
     new_interp->thread_data = mem_internal_allocate_zeroed_typed(Thread_data);
     INTERPRETER_LOCK_INIT(new_interp);
-    running_threads++;
+    ++running_threads;
     if (Interp_debug_TEST(interp, PARROT_THREAD_DEBUG_FLAG))
         fprintf(stderr, "running threads %d\n", running_threads);
 

Modified: trunk/src/utils.c
==============================================================================
--- trunk/src/utils.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/utils.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -845,7 +845,7 @@
     c.temp_reg = temp_reg;
 
     /* compute max_reg, the max reg number + 1 */
-    for (i = 0; i < n_regs; i++) {
+    for (i = 0; i < n_regs; ++i) {
         if (src_regs[i] > max_reg)
             max_reg = src_regs[i];
         if (dest_regs[i] > max_reg)
@@ -861,26 +861,26 @@
     c.reg_to_index = reg_to_index = mem_gc_allocate_n_zeroed_typed(interp, max_reg, int);
 
     /* init backup array */
-    for (i = 0; i < n_regs; i++)
+    for (i = 0; i < n_regs; ++i)
         backup[i] = -1;
 
     /* fill in the conversion array between a register number and its index */
-    for (i = 0; i < max_reg; i++)
+    for (i = 0; i < max_reg; ++i)
         reg_to_index[i] = -1;
-    for (i = 0; i < n_regs; i++) {
+    for (i = 0; i < n_regs; ++i) {
         const int index = dest_regs[i];
         if (index != src_regs[i]) /* get rid of self-assignment */
             reg_to_index[index] = i;
     }
 
     /* count the nb of successors for each reg index */
-    for (i = 0; i < n_regs; i++) {
+    for (i = 0; i < n_regs; ++i) {
         const int index = reg_to_index[ src_regs[i] ];
         if (index >= 0) /* not interested in the wells that have no preds */
-            nb_succ[ index ]++;
+            ++nb_succ[index];
     }
     /* process each well if any */
-    for (i = 0; i < n_regs; i++) {
+    for (i = 0; i < n_regs; ++i) {
         if (0 == nb_succ[i]) { /* a well */
             rec_climb_back_and_mark(i, &c);
         }
@@ -888,7 +888,7 @@
 
     /* process remaining dest registers not processed */
     /* remaining nodes are members of cycles without exits */
-    for (i = 0; i < n_regs; i++) {
+    for (i = 0; i < n_regs; ++i) {
         if (0 < nb_succ[i] && 0 > backup[i]) { /* not a well nor visited*/
             process_cycle_without_exit(i, &c);
         }

Modified: trunk/src/vtables.c
==============================================================================
--- trunk/src/vtables.c	Fri Apr 30 07:33:14 2010	(r46191)
+++ trunk/src/vtables.c	Fri Apr 30 08:27:15 2010	(r46192)
@@ -184,7 +184,7 @@
     ASSERT_ARGS(parrot_free_vtables)
     int i;
 
-    for (i = 0; i < interp->n_vtable_max; i++)
+    for (i = 0; i < interp->n_vtable_max; ++i)
         Parrot_destroy_vtable(interp, interp->vtables[i]);
 
     mem_internal_free(interp->vtables);
@@ -206,7 +206,7 @@
     ASSERT_ARGS(mark_vtables)
     INTVAL i;
 
-    for (i = 1; i < interp->n_vtable_max; i++) {
+    for (i = 1; i < interp->n_vtable_max; ++i) {
         const VTABLE * const vtable = interp->vtables[i];
 
         /* XXX dynpmc groups have empty slots for abstract objects */


More information about the parrot-commits mailing list