if (cfi_info->x16_as_x8)
        {
                uint8_t i;
-               for(i=0;i<2;i++)
+               for (i=0;i<2;i++)
                        target_read_memory(target, flash_address(bank, sector, offset+i), bank->bus_width, 1,
                                &data[i*bank->bus_width] );
        }
        if (cfi_info->x16_as_x8)
        {
                uint8_t i;
-               for(i=0;i<4;i++)
+               for (i=0;i<4;i++)
                        target_read_memory(target, flash_address(bank, sector, offset+i), bank->bus_width, 1,
                                &data[i*bank->bus_width] );
        }
 
        switch (wordsize)
        {
        case 4:
-               for(i = 0; i < chunk_count; i++)
+               for (i = 0; i < chunk_count; i++)
                {
                        target_buffer_set_u32(target, chunk + i * wordsize, pattern);
                }
                break;
        case 2:
-               for(i = 0; i < chunk_count; i++)
+               for (i = 0; i < chunk_count; i++)
                {
                        target_buffer_set_u16(target, chunk + i * wordsize, pattern);
                }
 
        reg1 = reg2 = reg3 = 0;
 
        /* Build up column parity */
-       for(i = 0; i < 256; i++) {
+       for (i = 0; i < 256; i++) {
                /* Get CP0 - CP5 from table */
                idx = nand_ecc_precalc_table[*dat++];
                reg1 ^= (idx & 0x3f);
 
                num_pages = 12;
        } else {
                /* 0xBD000000: Program flash size varies with device */
-               for(i=0; pic32mx_devs[i].name != NULL; i++)
+               for (i=0; pic32mx_devs[i].name != NULL; i++)
                        if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
                                num_pages = pic32mx_devs[i].pfm_size;
                                break;
                                 PIC32MX_MANUF_ID);
                return ERROR_FLASH_OPERATION_FAILED;
        }
-       for(i=0; pic32mx_devs[i].name != NULL; i++)
+       for (i=0; pic32mx_devs[i].name != NULL; i++)
                if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
                        printed = snprintf(buf, buf_size, "PIC32MX%s", pic32mx_devs[i].name);
                        break;
 
 {
     jim_wide i, res = 1;
     if ((b==0 && e!=0) || (e<0)) return 0;
-    for(i=0; i<e; i++) {res *= b;}
+    for (i=0; i<e; i++) {res *= b;}
     return res;
 }
 
           script = caseList[i+1];
         }
     }
-    for(; i < patCount && Jim_CompareStringImmediate(interp, script, "-");
+    for (; i < patCount && Jim_CompareStringImmediate(interp, script, "-");
         i += 2)
         script = caseList[i+1];
     if (script && Jim_CompareStringImmediate(interp, script, "-")) {
        int x;
 
        Jim_fprintf( p->interp, p->interp->cookie_stderr, "---args---\n");
-       for( x = 0 ; x < p->argc ; x++ ){
+       for ( x = 0 ; x < p->argc ; x++ ){
                Jim_fprintf( p->interp, p->interp->cookie_stderr, 
                                         "%2d) %s\n", 
                                         x, 
        }
 
        debug_string_obj = Jim_NewEmptyStringObj( interp );
-       for( x = 0 ; x < argc ; x++ ){
+       for ( x = 0 ; x < argc ; x++ ){
                Jim_AppendStrings( interp,
                                                   debug_string_obj,
                                                   Jim_GetString( argv[x], NULL ),
 
                GetModuleFileName (NULL, strExePath, MAX_PATH);
                *strrchr(strExePath, '\\')=0;
                strcat(strExePath, "/../lib/"PACKAGE);
-               for(p=strExePath; *p; p++) {
+               for (p=strExePath; *p; p++) {
                        if (*p == '\\')
                                *p = '/';
                }
 
 
        tap = NULL;
        total_ir_length = 0;
-       for(;;){
+       for (;;){
                tap = jtag_tap_next_enabled(tap);
                if ( tap == NULL ){
                        break;
        tap = NULL;
        chain_pos = 0;
        int val;
-       for(;;){
+       for (;;){
                tap = jtag_tap_next_enabled(tap);
                if ( tap == NULL ){
                        break;
 
 {
        tap_state_t x;
 
-       for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
+       for ( x = 0 ; x < TAP_NUM_STATES ; x++ ){
                /* be nice to the human */
                if ( 0 == strcasecmp( name, tap_state_name(x) ) ){
                        return x;
        DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
 
        tap_out_bits = 0;
-       for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
+       for (cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
        {
-               for(cur_bit = 0; cur_bit < 8; cur_bit++)
+               for (cur_bit = 0; cur_bit < 8; cur_bit++)
                {
                        // make sure we do not run off the end of the buffers
                        unsigned tap_bit = cur_byte * 8 + cur_bit;
 
 
 
        /* Wait for DTC to finish running command buffer */
-       for(i = 10;;) {
+       for (i = 10;;) {
                usb_err = ep1_generic_commandl(
                        pHDev, 4,
 
 
                        /* The rigamarole with the masks and doing it bit-by-bit is due to the fact that the scan buffer is LSb-first and the DTC code is MSb-first for hardware reasons.   It was that or craft a function to do the reversal, and that wouldn't work with bit-stuffing (supplying extra bits to use mostly byte operations), or any other scheme which would throw the byte alignment off. */
 
-                       for(
+                       for (
                                rq_p = dtc_queue.rq_head;
                                rq_p != NULL;
                                rq_p = rq_next
 
                                        dtc_mask = 1 << (8 - 1);
 
-                                       for(
+                                       for (
                                                ;
                                                bit_cnt;
                                                bit_cnt--
                                                dtc_mask = 1 << (bit_cnt - 1);
                                        }
 
-                                       for(
+                                       for (
                                                ;
                                                bit_cnt;
                                                bit_cnt--
        if (!tap_state_queue.length) return(retval);
        bits = 1;
        byte = 0;
-       for(i = tap_state_queue.length; i--;) {
+       for (i = tap_state_queue.length; i--;) {
 
                byte <<= 1;
                if (tap_state_queue.buffer & 1) {
                buffer[scan_size / 8] &= ((1 << ((scan_size - 1) % 8) + 1) - 1);
 
                printf("before scan:");
-               for(i = 0; i < (scan_size + 7) / 8; i++) {
+               for (i = 0; i < (scan_size + 7) / 8; i++) {
                        printf(" %02x", buffer[i]);
                }
                printf("\n");
                speed = rlink_speed_table[rlink_speed_table_size - 1].prescaler;
        }
 
-       for(i = rlink_speed_table_size; i--; ) {
+       for (i = rlink_speed_table_size; i--; ) {
                if (rlink_speed_table[i].prescaler == speed) {
                        if (dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc, rlink_speed_table[i].dtc_size) != 0) {
                                LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".\n", speed);
 ) {
        int     i;
 
-       for(i = rlink_speed_table_size; i--; ) {
+       for (i = rlink_speed_table_size; i--; ) {
                if (rlink_speed_table[i].prescaler == speed) {
                        *khz = rlink_speed_table[i].khz;
                        return(ERROR_OK);
                return ERROR_FAIL;
        }
 
-       for(i = rlink_speed_table_size; i--; ) {
+       for (i = rlink_speed_table_size; i--; ) {
                if (rlink_speed_table[i].khz <= khz) {
                        *speed = rlink_speed_table[i].prescaler;
                        return(ERROR_OK);
 
        busses = usb_get_busses();
 
-       for(bus = busses; bus; bus = bus->next)
+       for (bus = busses; bus; bus = bus->next)
        {
                struct usb_device *dev;
 
-               for(dev = bus->devices; dev; dev = dev->next)
+               for (dev = bus->devices; dev; dev = dev->next)
                {
                        if ( (dev->descriptor.idVendor == USB_IDVENDOR) && (dev->descriptor.idProduct == USB_IDPRODUCT) )
                        {
 
        /* The device starts out in an unknown state on open.  As such, result reads time out, and it's not even known whether the command was accepted.  So, for this first command, we issue it repeatedly until its response doesn't time out.  Also, if sending a command is going to time out, we'll find that out here. */
        /* It must be possible to open the device in such a way that this special magic isn't needed, but, so far, it escapes us. */
-       for(i = 0; i < 5; i++) {
+       for (i = 0; i < 5; i++) {
                j = ep1_generic_commandl(
                        pHDev, 1,
                        EP1_CMD_GET_FWREV
 
                        const char *cpA;
                        const char *cpS;
                        cpA = args[ argc-1 ];
-                       for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
+                       for ( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
                                cpS = tap_state_name( endstate );
                                if ( 0 == strcmp( cpA, cpS ) ){
                                        break;
 
        enum tap_state pause_state = TAP_DRSHIFT;
 
        jtag_tap_t *tap, *nextTap;
-       for(tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
+       for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
        {
                nextTap=jtag_tap_next_enabled(tap);
                if (nextTap==NULL)
 
        int j;
        int scan_size = 0;
        jtag_tap_t *tap, *nextTap;
-       for(tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
+       for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
        {
                nextTap=jtag_tap_next_enabled(tap);
                tap_state_t end_state;
 
        int j;
        jtag_tap_t *tap, *nextTap;
-       for(tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
+       for (tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
        {
                nextTap=jtag_tap_next_enabled(tap);
                int found=0;
 
                                // binary packets spew junk into the debug log stream
                                char buf[ 50 ];
                                int x;
-                               for( x = 0 ; (x < 49) && (packet[x] != ':') ; x++ ){
+                               for ( x = 0 ; (x < 49) && (packet[x] != ':') ; x++ ){
                                        buf[x] = packet[x];
                                }
                                buf[x] = 0;
 
                uint32_t i, t32;
                uint16_t t16;
 
-               for(i = 0; i < (count*size); i += size)
+               for (i = 0; i < (count*size); i += size)
                {
                        switch (size)
                        {
                uint32_t i, t32;
                uint16_t t16;
 
-               for(i = 0; i < (count*size); i += size)
+               for (i = 0; i < (count*size); i += size)
                {
                        switch (size) 
                        {
 
                        b = 1;
                        break;
                }
-               for( x = 0 ; x < c ; x++ ){
+               for ( x = 0 ; x < c ; x++ ){
                        e = target_write_memory( target, a, b, 1, target_buf );
                        if ( e != ERROR_OK ){
                                Jim_SetResult_sprintf( interp, "Error writing @ 0x%08x: %d\n", (int)(a), e );
                        Jim_fprintf( interp, interp->cookie_stdout, "0x%08x ", (int)(a) );
                        switch ( b ){
                        case 4:
-                               for( x = 0 ; (x < 16) && (x < y) ; x += 4 ){
+                               for ( x = 0 ; (x < 16) && (x < y) ; x += 4 ){
                                        z = target_buffer_get_u32( target, &(target_buf[ x * 4 ]) );
                                        Jim_fprintf( interp, interp->cookie_stdout, "%08x ", (int)(z) );
                                }
-                               for( ; (x < 16) ; x += 4 ){
+                               for ( ; (x < 16) ; x += 4 ){
                                        Jim_fprintf( interp, interp->cookie_stdout, "         " );
                                }
                                break;
                        case 2:
-                               for( x = 0 ; (x < 16) && (x < y) ; x += 2 ){
+                               for ( x = 0 ; (x < 16) && (x < y) ; x += 2 ){
                                        z = target_buffer_get_u16( target, &(target_buf[ x * 2 ]) );
                                        Jim_fprintf( interp, interp->cookie_stdout, "%04x ", (int)(z) );
                                }
-                               for( ; (x < 16) ; x += 2 ){
+                               for ( ; (x < 16) ; x += 2 ){
                                        Jim_fprintf( interp, interp->cookie_stdout, "     " );
                                }
                                break;
                        case 1:
                        default:
-                               for( x = 0 ; (x < 16) && (x < y) ; x += 1 ){
+                               for ( x = 0 ; (x < 16) && (x < y) ; x += 1 ){
                                        z = target_buffer_get_u8( target, &(target_buf[ x * 4 ]) );
                                        Jim_fprintf( interp, interp->cookie_stdout, "%02x ", (int)(z) );
                                }
-                               for( ; (x < 16) ; x += 1 ){
+                               for ( ; (x < 16) ; x += 1 ){
                                        Jim_fprintf( interp, interp->cookie_stdout, "   " );
                                }
                                break;
                        }
                        /* ascii-ify the bytes */
-                       for( x = 0 ; x < y ; x++ ){
+                       for ( x = 0 ; x < y ; x++ ){
                                if ( (target_buf[x] >= 0x20) &&
                                        (target_buf[x] <= 0x7e) ){
                                        /* good */
        e = Jim_GetOpt_String( goi, &cp2, NULL );
        cp = cp2;
        /* now does target type exist */
-       for( x = 0 ; target_types[x] ; x++ ){
+       for ( x = 0 ; target_types[x] ; x++ ){
                if ( 0 == strcmp( cp, target_types[x]->name ) ){
                        /* found */
                        break;
        }
        if ( target_types[x] == NULL ){
                Jim_SetResult_sprintf( goi->interp, "Unknown target type %s, try one of ", cp );
-               for( x = 0 ; target_types[x] ; x++ ){
+               for ( x = 0 ; target_types[x] ; x++ ){
                        if ( target_types[x+1] ){
                                Jim_AppendStrings( goi->interp,
                                                                   Jim_GetResult(goi->interp),
                        return JIM_ERR;
                }
                Jim_SetResult( goi.interp, Jim_NewListObj( goi.interp, NULL, 0 ) );
-               for( x = 0 ; target_types[x] ; x++ ){
+               for ( x = 0 ; target_types[x] ; x++ ){
                        Jim_ListAppendElement( goi.interp,
                                                                   Jim_GetResult(goi.interp),
                                                                   Jim_NewStringObj( goi.interp, target_types[x]->name, -1 ) );
 
         * we can't enter User mode on an XScale (unpredictable),
         * but User shares registers with SYS
         */
-       for(i = 1; i < 7; i++)
+       for (i = 1; i < 7; i++)
        {
                int valid = 1;
 
        * we can't enter User mode on an XScale (unpredictable),
        * but User shares registers with SYS
        */
-       for(i = 1; i < 7; i++)
+       for (i = 1; i < 7; i++)
        {
                int dirty = 0;
 
 
 
                                LOG_DEBUG("%s %d", op_name, xsdrsize);
 
-                               for( attempt=0; attempt<limit;  ++attempt )
+                               for ( attempt=0; attempt<limit;  ++attempt )
                                {
                                        scan_field_t field;
 
                                if (limit < 1)
                                        limit = 1;
 
-                               for( attempt=0; attempt<limit;  ++attempt )
+                               for ( attempt=0; attempt<limit;  ++attempt )
                                {
                                        scan_field_t field;
 
 
        
        while (1)
        {
-               for(i = 0; i < 500000; i++)
+               for (i = 0; i < 500000; i++)
                        mPORTDToggleBits(BIT_0);
-               for(i = 0; i < 500000; i++)
+               for (i = 0; i < 500000; i++)
                        mPORTDToggleBits(BIT_1);
-               for(i = 0; i < 500000; i++)
+               for (i = 0; i < 500000; i++)
                        mPORTDToggleBits(BIT_2);
        }