for ( ; i < buflen ; ) { switch(ival = bytes[i++]) { case '0': if (nDigits > 0) { nTrailingZeroes++; } else { exponent--; } break; // switch case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (nTrailingZeroes > 0) { if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS) { significand *= LONG_10_POWERS[nTrailingZeroes]; nTrailingZeroes = 0; } // else catch oversize below } if (nDigits++ < MAX_DECIMAL_DIGITS) { significand = significand*10L + (long)((int)ival-(int)'0'); break; // switch } else { state = SDIGIT; break states; } case 'e': case 'E': state = SOPTEXP_STRICT; break states; case '_': if (i >= buflen || bytes[i] < '0' || bytes[i] > '9') { state = SERR_NOT_STRICT; break states; } break; // switch default: // only whitespace allowed after value for strict for ( --i; i < buflen && isWhitespace(bytes[i]); i++); state = i < buflen ? SERR_NOT_STRICT : SOPTCALC; break states; } // switch }
switch(ival = bytes[i++]) { case '0': if (nDigits > 0) { nTrailingZeroes++; } else { exponent--; } break; // switch case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (nTrailingZeroes > 0) { if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS) { significand *= LONG_10_POWERS[nTrailingZeroes]; nTrailingZeroes = 0; } // else catch oversize below } if (nDigits++ < MAX_DECIMAL_DIGITS) { significand = significand*10L + (long)((int)ival-(int)'0'); break; // switch } else { state = SDIGIT; break states; } default: // no dec digits after '.', error for strict state = SERR_NOT_STRICT; break states; }
Clone fragments detected by clone detection tool
File path: /jruby-1.4.0/src/org/jruby/util/Convert.java File path: /jruby-1.4.0/src/org/jruby/util/Convert.java
Method name: double byteArrayToDouble(byte[], int, int, boolean) Method name: double byteArrayToDouble(byte[], int, int, boolean)
Number of AST nodes: 39 Number of AST nodes: 27
1
for ( ; i < buflen ; ) {
2
                    switch(ival = bytes[i++]) {
1
switch(ival = bytes[i++]) {
3
                    case '0':
2
                    case '0':
4
                        if (nDigits > 0) {
3
                        if (nDigits > 0) {
5
                            nTrailingZeroes++;
4
                            nTrailingZeroes++;
6
                        } else {
5
                        } else {
7
                            exponent--;
6
                            exponent--;
8
                        }
7
                        }
9
                        break; // switch
8
                        break; // switch
10
                    case '1': case '2': case '3': case '4':
9
                    case '1': case '2': case '3': case '4':
11
                    case '5': case '6': case '7': case '8': case '9':
10
                    case '5': case '6': case '7': case '8': case '9':
12
                        if (nTrailingZeroes > 0) {
11
                        if (nTrailingZeroes > 0) {
13
                            if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS) {
12
                            if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS) {
14
                                significand *= LONG_10_POWERS[nTrailingZeroes];
13
                                significand *= LONG_10_POWERS[nTrailingZeroes];
15
                                nTrailingZeroes = 0;
14
                                nTrailingZeroes = 0;
16
                            } // else catch oversize below
15
                            } // else catch oversize below
17
                        }
16
                        }
18
                        if (nDigits++ < MAX_DECIMAL_DIGITS) {
17
                        if (nDigits++ < MAX_DECIMAL_DIGITS) {
19
                            significand = significand*10L + (long)((int)ival-(int)'0');
18
                            significand = significand*10L + (long)((int)ival-(int)'0');
20
                            break; // switch
19
                            break; // switch
21
                        } else {
20
                        } else {
22
                            state = SDIGIT;
21
                            state = SDIGIT;
23
                            break states;
22
                            break states;
24
                        }
23
                        }
25
                    case 'e':
26
                    case 'E':
27
                        state = SOPTEXP_STRICT;
28
                        break states;
29
                    case '_':
30
                        if (i >= buflen || bytes[i] < '0' || bytes[i] > '9') {
31
                            state = SERR_NOT_STRICT;
32
                            break states;
33
                        }
34
                        break; // switch
35
                    default:
24
                    default:
36
                        // only whitespace allowed after value for strict
25
                        // no dec digits after '.', error for strict
37
                        for ( --i; i < buflen && isWhitespace(bytes[i]); i++);
26
                        
38
                        state = i < buflen ? SERR_NOT_STRICT : SOPTCALC; 
27
state = SERR_NOT_STRICT;
39
                        break states;
28
                        break states;
40
                    } // switch
29
                    
30
    
41
                }
31
                    }
Summary
Number of common nesting structure subtrees1
Number of refactorable cases0
Number of non-refactorable cases1
Time elapsed for finding largest common nesting structure subtrees (ms)3.7
Clones locationClones are in the same method
Number of node comparisons195
  1. {Non-refactorable}
    Mapping Summary
    Number of mapped statements27
    Number of unmapped statements in the first code fragment11
    Number of unmapped statements in the second code fragment0
    Time elapsed for statement mapping (ms)56.0
    Clone typeType 3
    Mapped Statements
    ID Statement ID Statement
    353
    switch (ival = bytes[i++])
    323
    switch (ival = bytes[i++])
    354
    case '0':
    324
    case '0':
    355
    if (nDigits > 0)
    325
    if (nDigits > 0)
    356
    nTrailingZeroes++;
    326
    nTrailingZeroes++;
    else
    else
    357
    exponent--;
    327
    exponent--;
    358
    break;
    328
    break;
    359
    case '1':
    329
    case '1':
    360
    case '2':
    330
    case '2':
    361
    case '3':
    331
    case '3':
    362
    case '4':
    332
    case '4':
    363
    case '5':
    333
    case '5':
    364
    case '6':
    334
    case '6':
    365
    case '7':
    335
    case '7':
    366
    case '8':
    336
    case '8':
    367
    case '9':
    337
    case '9':
    368
    if (nTrailingZeroes > 0)
    338
    if (nTrailingZeroes > 0)
    369
    if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS)
    339
    if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS)
    370
    significand *= LONG_10_POWERS[nTrailingZeroes];
    340
    significand *= LONG_10_POWERS[nTrailingZeroes];
    371
    nTrailingZeroes = 0;
    341
    nTrailingZeroes = 0;
    372
    if (nDigits++ < MAX_DECIMAL_DIGITS)
    342
    if (nDigits++ < MAX_DECIMAL_DIGITS)
    373
    significand = significand * 10L + (long)((int)ival - (int)'0');
    343
    significand = significand * 10L + (long)((int)ival - (int)'0');
    374
    break;
    344
    break;
    else
    else
    375
    state = SDIGIT;
    345
    state = SDIGIT;
    376
    break states;
    346
    break states;
    377
    case 'e':
                                
    378
    case 'E':
                                
    379
    state = SOPTEXP_STRICT;
    379
    state = SOPTEXP_STRICT;
    348
    state = SERR_NOT_STRICT;
    Differences
    Expression1Expression2Difference
    SOPTEXP_STRICTSERR_NOT_STRICTVARIABLE_NAME_MISMATCH
    348
    state = SERR_NOT_STRICT;
    380
    break states;
    380
    break states;
    Preondition Violations
    Unmatched break states;
                                        
    381
    case '_':
                                
    382
    if (i >= buflen || bytes[i] < '0' || bytes[i] > '9')
    382
    if (i >= buflen || bytes[i] < '0' || bytes[i] > '9')
    Preondition Violations
    Unmatched statement if(i >= buflen || bytes[i] < '0' || bytes[i] > '9') cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                                                                    
    383
    state = SERR_NOT_STRICT;
    383
    state = SERR_NOT_STRICT;
    Preondition Violations
    Unmatched statement state=SERR_NOT_STRICT; cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                          
    384
    break states;
    384
    break states;
    Preondition Violations
    Unmatched break states;
                                        
    385
    break;
    385
    break;
    Preondition Violations
    Unmatched break;
                          
    386
    default:
    347
    default:
    387
    for (--i; i < buflen && isWhitespace(bytes[i]); i++)
    387
    for (--i; i < buflen && isWhitespace(bytes[i]); i++)
    Preondition Violations
    Unmatched statement for(--i; i < buflen && isWhitespace(bytes[i]); i++) cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                                                                    
    388
    ;
                
    389
    state = i < buflen ? SERR_NOT_STRICT : SOPTCALC;
    389
    state = i < buflen ? SERR_NOT_STRICT : SOPTCALC;
    Preondition Violations
    Unmatched statement state=i < buflen ? SERR_NOT_STRICT : SOPTCALC; cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                                                          
    390
    break states;
    349
    break states;
    Precondition Violations (8)
    Row Violation
    1Unmatched break states;
    2Unmatched statement if(i >= buflen || bytes[i] < '0' || bytes[i] > '9') cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    3Unmatched statement state=SERR_NOT_STRICT; cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    4Unmatched break states;
    5Unmatched break;
    6Unmatched statement for(--i; i < buflen && isWhitespace(bytes[i]); i++) cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    7Unmatched statement state=i < buflen ? SERR_NOT_STRICT : SOPTCALC; cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    8Clone fragment #1 returns variables i, ival, nDigits, nTrailingZeroes, significand, exponent , while Clone fragment #2 returns variables i, ival, nDigits, nTrailingZeroes, significand, exponent