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 }
if (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; } default: // no dec digits, end of parseable data, go to calc state = SOPTCALC; break states; } // switch }
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: 28
1
for ( ; i < buflen ; ) {
1
if (i < buflen) {
2
                    switch(ival = bytes[i++]) {
2
                    switch(ival = bytes[i++]) {
3
                    case '0':
3
                    case '0':
4
                        if (nDigits > 0) {
4
                        if (nDigits > 0) {
5
                            nTrailingZeroes++;
5
                            nTrailingZeroes++;
6
                        } else {
6
                        } else {
7
                            exponent--;
7
                            exponent--;
8
                        }
8
                        }
9
                        break; // switch
9
                        break; // switch
10
                    case '1': case '2': case '3': case '4':
10
                    case '1': case '2': case '3': case '4':
11
                    case '5': case '6': case '7': case '8': case '9':
11
                    case '5': case '6': case '7': case '8': case '9':
12
                        if (nTrailingZeroes > 0) {
12
                        if (nTrailingZeroes > 0) {
13
                            if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS) {
13
                            if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS) {
14
                                significand *= LONG_10_POWERS[nTrailingZeroes];
14
                                significand *= LONG_10_POWERS[nTrailingZeroes];
15
                                nTrailingZeroes = 0;
15
                                nTrailingZeroes = 0;
16
                            } // else catch oversize below
16
                            } // else catch oversize below
17
                        }
17
                        }
18
                        if (nDigits++ < MAX_DECIMAL_DIGITS) {
18
                        if (nDigits++ < MAX_DECIMAL_DIGITS) {
19
                            significand = significand*10L + (long)((int)ival-(int)'0');
19
                            significand = significand*10L + (long)((int)ival-(int)'0');
20
                            break; // switch
20
                            break; // switch
21
                        } else {
21
                        } else {
22
                            state = SDIGIT;
22
                            state = SDIGIT;
23
                            break states;
23
                            break states;
24
                        }
24
                        }
25
                    case 'e':
25
                    
26
                    case 'E':
27
                        state = SOPTEXP_STRICT;
28
                        break states;
29
                    case '_':
30
                        if (i >= buflen || bytes[i] < '0' || bytes[i] > '9') {
31
    
26
default:
27
                        // no dec digits, end of parseable data, go to calc
32
                        state = SERR_NOT_STRICT;
28
                        state = S
33
    
29
OPTCALC;
34
                        break states;
30
                        break states;
35
                        }
31
                        
36
                        break; // switch
37
                    default:
38
                        // only whitespace allowed after value for strict
39
                        for ( --i; i < buflen && isWhitespace(bytes[i]); i++);
40
                        state = i < buflen ? SERR_NOT_STRICT : SOPTCALC; 
41
                        break states;
42
                    } // switch
32
                    } // switch
43
                }
33
                }
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)50.6
    Clone typeType 3
    Mapped Statements
    ID Statement ID Statement
    353
    switch (ival = bytes[i++])
    127
    switch (ival = bytes[i++])
    354
    case '0':
    128
    case '0':
    355
    if (nDigits > 0)
    129
    if (nDigits > 0)
    356
    nTrailingZeroes++;
    130
    nTrailingZeroes++;
    else
    else
    357
    exponent--;
    131
    exponent--;
    358
    break;
    132
    break;
    359
    case '1':
    133
    case '1':
    360
    case '2':
    134
    case '2':
    361
    case '3':
    135
    case '3':
    362
    case '4':
    136
    case '4':
    363
    case '5':
    137
    case '5':
    364
    case '6':
    138
    case '6':
    365
    case '7':
    139
    case '7':
    366
    case '8':
    140
    case '8':
    367
    case '9':
    141
    case '9':
    368
    if (nTrailingZeroes > 0)
    142
    if (nTrailingZeroes > 0)
    369
    if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS)
    143
    if ((nDigits += nTrailingZeroes) < MAX_DECIMAL_DIGITS)
    370
    significand *= LONG_10_POWERS[nTrailingZeroes];
    144
    significand *= LONG_10_POWERS[nTrailingZeroes];
    371
    nTrailingZeroes = 0;
    145
    nTrailingZeroes = 0;
    372
    if (nDigits++ < MAX_DECIMAL_DIGITS)
    146
    if (nDigits++ < MAX_DECIMAL_DIGITS)
    373
    significand = significand * 10L + (long)((int)ival - (int)'0');
    147
    significand = significand * 10L + (long)((int)ival - (int)'0');
    374
    break;
    148
    break;
    else
    else
    375
    state = SDIGIT;
    149
    state = SDIGIT;
    376
    break states;
    150
    break states;
    377
    case 'e':
                                
    378
    case 'E':
                                
    379
    state = SOPTEXP_STRICT;
    379
    state = SOPTEXP_STRICT;
    152
    state = SOPTCALC;
    Differences
    Expression1Expression2Difference
    SOPTEXP_STRICTSOPTCALCVARIABLE_NAME_MISMATCH
    152
    state = SOPTCALC;
    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:
    151
    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;
    153
    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