expstdop.java

UML设计测试工具

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        int i1 = ((IntegerValue) args[0]).value();
        int i2 = ((IntegerValue) args[1]).value();
        return new IntegerValue(i1 / i2);
    }
}

// --------------------------------------------------------

/* < : Number x Number -> Boolean */
final class Op_number_less extends OpGeneric {
    public String name() { return "<"; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isNumber()
                 && params[1].isNumber() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        double d1;
        double d2;
        if (args[0].isInteger() )
            d1 = ((IntegerValue) args[0]).value();
        else
            d1 = ((RealValue) args[0]).value();

        if (args[1].isInteger() )
            d2 = ((IntegerValue) args[1]).value();
        else
            d2 = ((RealValue) args[1]).value();
        return BooleanValue.get(d1 < d2);
    }
}

// --------------------------------------------------------

/* > : Number x Number -> Boolean */
final class Op_number_greater extends OpGeneric {
    public String name() { return ">"; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isNumber()
                 && params[1].isNumber() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        double d1;
        double d2;
        if (args[0].isInteger() )
            d1 = ((IntegerValue) args[0]).value();
        else
            d1 = ((RealValue) args[0]).value();

        if (args[1].isInteger() )
            d2 = ((IntegerValue) args[1]).value();
        else
            d2 = ((RealValue) args[1]).value();
        return BooleanValue.get(d1 > d2);
    }
}

// --------------------------------------------------------

/* <= : Number x Number -> Boolean */
final class Op_number_lessequal extends OpGeneric {
    public String name() { return "<="; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isNumber()
                 && params[1].isNumber() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        double d1;
        double d2;
        if (args[0].isInteger() )
            d1 = ((IntegerValue) args[0]).value();
        else
            d1 = ((RealValue) args[0]).value();

        if (args[1].isInteger() )
            d2 = ((IntegerValue) args[1]).value();
        else
            d2 = ((RealValue) args[1]).value();
        return BooleanValue.get(d1 <= d2);
    }
}

// --------------------------------------------------------

/* >= : Number x Number -> Boolean */
final class Op_number_greaterequal extends OpGeneric {
    public String name() { return ">="; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isNumber()
                 && params[1].isNumber() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        double d1;
        double d2;
        if (args[0].isInteger() )
            d1 = ((IntegerValue) args[0]).value();
        else
            d1 = ((RealValue) args[0]).value();

        if (args[1].isInteger() )
            d2 = ((IntegerValue) args[1]).value();
        else
            d2 = ((RealValue) args[1]).value();
        return BooleanValue.get(d1 >= d2);
    }
}

// --------------------------------------------------------
// 
// String operations. 
//
// --------------------------------------------------------

/* size : String -> Integer */
final class Op_string_size extends OpGeneric {
    public String name() { return "size"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isString() )
            ? TypeFactory.mkInteger() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        int res = ((StringValue) args[0]).value().length();
        return new IntegerValue(res);
    }
}


// --------------------------------------------------------

/* concat : String x String -> String */
final class Op_string_concat extends OpGeneric {
    public String name() { return "concat"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isString()
                 && params[1].isString() )
            ? params[0] : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        String s1 = ((StringValue) args[0]).value();
        String s2 = ((StringValue) args[1]).value();
        return new StringValue(s1 + s2);
    }
}

// --------------------------------------------------------

/* toUpper : String -> String */
final class Op_string_toUpper extends OpGeneric {
    public String name() { return "toUpper"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isString() )
            ? params[0] : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        String s1 = ((StringValue) args[0]).value();
        return new StringValue(s1.toUpperCase());
    }
}

// --------------------------------------------------------

/* toLower : String -> String */
final class Op_string_toLower extends OpGeneric {
    public String name() { return "toLower"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isString() )
            ? params[0] : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        String s1 = ((StringValue) args[0]).value();
        return new StringValue(s1.toLowerCase());
    }
}

// --------------------------------------------------------

/* substring : String x Integer x Integer -> String */
final class Op_string_substring extends OpGeneric {
    public String name() { return "substring"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 3
                 && params[0].isString()
                 && params[1].isInteger()
                 && params[2].isInteger() )
            ? params[0] : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        String s1 = ((StringValue) args[0]).value();
        int lower = ((IntegerValue) args[1]).value();
        int upper = ((IntegerValue) args[2]).value();
        
        // return empty string in case of invalid range
        String s;
        try {
            s = s1.substring(lower - 1, upper);
        } catch (StringIndexOutOfBoundsException e) {
            s = "";
        }
        return new StringValue(s);
    }
}

// --------------------------------------------------------

/* < : String x String -> Boolean */
final class Op_string_less extends OpGeneric {
    public String name() { return "<"; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isString()
                 && params[1].isString() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        int c = args[0].compareTo(args[1]);
        return ( c < 0 ) ? BooleanValue.TRUE : BooleanValue.FALSE;
    }
}

// --------------------------------------------------------

/* > : String x String -> Boolean */
final class Op_string_greater extends OpGeneric {
    public String name() { return ">"; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isString()
                 && params[1].isString() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        int c = args[0].compareTo(args[1]);
        return ( c > 0 ) ? BooleanValue.TRUE : BooleanValue.FALSE;
    }
}

// --------------------------------------------------------

/* <= : String x String -> Boolean */
final class Op_string_lessequal extends OpGeneric {
    public String name() { return "<="; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isString()
                 && params[1].isString() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        int c = args[0].compareTo(args[1]);
        return ( c <= 0 ) ? BooleanValue.TRUE : BooleanValue.FALSE;
    }
}

// --------------------------------------------------------

/* >= : String x String -> Boolean */
final class Op_string_greaterequal extends OpGeneric {
    public String name() { return ">="; }
    public int kind() { return PREDICATE; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isString()
                 && params[1].isString() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        int c = args[0].compareTo(args[1]);
        return ( c >= 0 ) ? BooleanValue.TRUE : BooleanValue.FALSE;
    }
}

// --------------------------------------------------------
//
// Boolean operations. 
//
// --------------------------------------------------------

/**
 * This class is the base class for boolean operations. Boolean
 * operations need special treatment of undefined arguments. Also,
 * short-circuit evaluation may be used to speed up the evaluation
 * process.
 */
abstract class BooleanOperation extends OpGeneric {
    public int kind() { return SPECIAL; }
    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        throw new RuntimeException("Use evalWithArgs");
    }
    public abstract Value evalWithArgs(EvalContext ctx, Expression args[]);
}

// --------------------------------------------------------

/* or : Boolean x Boolean -> Boolean */
final class Op_boolean_or extends BooleanOperation {
    public String name() { return "or"; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isBoolean()
                 && params[1].isBoolean() )
            ? params[0] : null;
    }

    public Value evalWithArgs(EvalContext ctx, Expression args[]) {
        Value v1 = args[0].eval(ctx);
        if (v1.isDefined() ) {
            boolean b1 = ((BooleanValue) v1).value();
            if (b1 ) 
                return BooleanValue.TRUE;
            else {
                Value v2 = args[1].eval(ctx);
                return v2;
            }
        } else {
            Value v2 = args[1].eval(ctx);
            if (v2.isDefined() ) {
                boolean b2 = ((BooleanValue) v2).value();
                if (b2 )
                    return BooleanValue.TRUE;
            }
            return new UndefinedValue(TypeFactory.mkBoolean());
        }
    }
}

// --------------------------------------------------------

/* xor : Boolean x Boolean -> Boolean */
final class Op_boolean_xor extends BooleanOperation {
    public String name() { return "xor"; }