switch(kind) { // boolean case LT: case LTX: return new Boolean(lhs < rhs); case GT: case GTX: return new Boolean(lhs > rhs); case EQ: return new Boolean(lhs == rhs); case LE: case LEX: return new Boolean(lhs <= rhs); case GE: case GEX: return new Boolean(lhs >= rhs); case NE: return new Boolean(lhs != rhs); // arithmetic case PLUS: return new Double(lhs + rhs); case MINUS: return new Double(lhs - rhs); case STAR: return new Double(lhs * rhs); case SLASH: return new Double(lhs / rhs); case MOD: return new Double(lhs % rhs); // can't shift floating-point values case LSHIFT: case LSHIFTX: case RSIGNEDSHIFT: case RSIGNEDSHIFTX: case RUNSIGNEDSHIFT: case RUNSIGNEDSHIFTX: throw new UtilEvalError("Can't shift doubles"); default: throw new InterpreterError( "Unimplemented binary double operator"); }
switch(kind) { // boolean case LT: case LTX: return new Boolean(lhs < rhs); case GT: case GTX: return new Boolean(lhs > rhs); case EQ: return new Boolean(lhs == rhs); case LE: case LEX: return new Boolean(lhs <= rhs); case GE: case GEX: return new Boolean(lhs >= rhs); case NE: return new Boolean(lhs != rhs); // arithmetic case PLUS: return new Float(lhs + rhs); case MINUS: return new Float(lhs - rhs); case STAR: return new Float(lhs * rhs); case SLASH: return new Float(lhs / rhs); case MOD: return new Float(lhs % rhs); // can't shift floats case LSHIFT: case LSHIFTX: case RSIGNEDSHIFT: case RSIGNEDSHIFTX: case RUNSIGNEDSHIFT: case RUNSIGNEDSHIFTX: throw new UtilEvalError("Can't shift floats "); default: throw new InterpreterError( "Unimplemented binary float operator"); }
Clone fragments detected by clone detection tool
File path: /jEdit-4.2/src/bsh/Primitive.java File path: /jEdit-4.2/src/bsh/Primitive.java
Method name: Method name:
Number of AST nodes: 0 Number of AST nodes: 0
1
switch(kind)
1
switch(kind)
2
        {
2
        {
3
            // boolean
3
            // boolean
4
            case LT:
4
            case LT:
5
            case LTX:
5
            case LTX:
6
                return new Boolean(lhs < rhs);
6
                return new Boolean(lhs < rhs);
7
            case GT:
7
            case GT:
8
            case GTX:
8
            case GTX:
9
                return new Boolean(lhs > rhs);
9
                return new Boolean(lhs > rhs);
10
            case EQ:
10
            case EQ:
11
                return new Boolean(lhs == rhs);
11
                return new Boolean(lhs == rhs);
12
            case LE:
12
            case LE:
13
            case LEX:
13
            case LEX:
14
                return new Boolean(lhs <= rhs);
14
                return new Boolean(lhs <= rhs);
15
            case GE:
15
            case GE:
16
            case GEX:
16
            case GEX:
17
                return new Boolean(lhs >= rhs);
17
                return new Boolean(lhs >= rhs);
18
            case NE:
18
            case NE:
19
                return new Boolean(lhs != rhs);
19
                return new Boolean(lhs != rhs);
20
            // arithmetic
20
            // arithmetic
21
            case PLUS:
21
            case PLUS:
22
                return new Double(lhs + rhs);
22
                return new Float(lhs + rhs);
23
            case MINUS:
23
            case MINUS:
24
                return new Double(lhs - rhs);
24
                return new Float(lhs - rhs);
25
            case STAR:
25
            case STAR:
26
                return new Double(lhs * rhs);
26
                return new Float(lhs * rhs);
27
            case SLASH:
27
            case SLASH:
28
                return new Double(lhs / rhs);
28
                return new Float(lhs / rhs);
29
            case MOD:
29
            case MOD:
30
                return new Double(lhs % rhs);
30
                return new Float(lhs % rhs);
31
            // can't shift floating-point values
31
            // can't shift floats
32
            case LSHIFT:
32
            case LSHIFT:
33
            case LSHIFTX:
33
            case LSHIFTX:
34
            case RSIGNEDSHIFT:
34
            case RSIGNEDSHIFT:
35
            case RSIGNEDSHIFTX:
35
            case RSIGNEDSHIFTX:
36
            case RUNSIGNEDSHIFT:
36
            case RUNSIGNEDSHIFT:
37
            case RUNSIGNEDSHIFTX:
37
            case RUNSIGNEDSHIFTX:
38
                throw new UtilEvalError("Can't shift doubles");
38
                throw new UtilEvalError("Can't shift floats ");
39
            default:
39
            default:
40
                throw new InterpreterError(
40
                throw new InterpreterError(
41
					"Unimplemented binary double operator");
41
					"Unimplemented binary float operator");
42
        }
42
        }
Summary
Number of common nesting structure subtrees0
Number of refactorable cases0
Number of non-refactorable cases0
Time elapsed for finding largest common nesting structure subtrees (ms)0.0
Clones location
Number of node comparisons0