| /******************************************************************************* |
| * Copyright (c) 2002, 2015 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.debug.tests.eval.generator; |
| |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.Writer; |
| |
| import org.eclipse.debug.internal.core.IInternalDebugCoreConstants; |
| |
| public class TestGenerator { |
| |
| static protected int getPromotionType(int left, int right) { |
| return fTypeTable[left][right]; |
| } |
| |
| static protected int getUnaryPromotionType(int type) { |
| return fTypeTable[type][T_int]; |
| } |
| |
| static protected boolean needCast(int type1, int type2) { |
| if (type1 == type2) { |
| return false; |
| } |
| switch (type1) { |
| case T_short: |
| case T_byte: |
| return type1 < type2 || type2 == T_char; |
| case T_char: |
| return true; |
| case T_int: |
| return type2 >= T_long; |
| case T_long: |
| return type2 == T_float || type2 == T_double; |
| case T_float: |
| return type2 == T_double; |
| case T_double: |
| return false; |
| default: |
| return true; |
| } |
| } |
| |
| static final int T_undefined = 0; |
| static final int T_object = 1; |
| static final int T_char = 2; |
| static final int T_byte = 3; |
| static final int T_short = 4; |
| static final int T_boolean = 5; |
| static final int T_void = 6; |
| static final int T_long = 7; |
| static final int T_double = 8; |
| static final int T_float = 9; |
| static final int T_int = 10; |
| static final int T_String = 11; |
| static final int T_null = 12; |
| |
| private static final int[][] fTypeTable= { |
| /* undefined */ {T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined}, |
| /* object */ {T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_String, T_undefined}, |
| /* char */ {T_undefined, T_undefined, T_int, T_int, T_int, T_undefined, T_undefined, T_long, T_double, T_float, T_int, T_String, T_undefined}, |
| /* byte */ {T_undefined, T_undefined, T_int, T_int, T_int, T_undefined, T_undefined, T_long, T_double, T_float, T_int, T_String, T_undefined}, |
| /* short */ {T_undefined, T_undefined, T_int, T_int, T_int, T_undefined, T_undefined, T_long, T_double, T_float, T_int, T_String, T_undefined}, |
| /* boolean */ {T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_boolean, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_String, T_undefined}, |
| /* void */ {T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined}, |
| /* long */ {T_undefined, T_undefined, T_long, T_long, T_long, T_undefined, T_undefined, T_long, T_double, T_float, T_long, T_String, T_undefined}, |
| /* double */ {T_undefined, T_undefined, T_double, T_double, T_double, T_undefined, T_undefined, T_double, T_double, T_double, T_double, T_String, T_undefined}, |
| /* float */ {T_undefined, T_undefined, T_float, T_float, T_float, T_undefined, T_undefined, T_float, T_double, T_float, T_float, T_String, T_undefined}, |
| /* int */ {T_undefined, T_undefined, T_int, T_int, T_int, T_undefined, T_undefined, T_long, T_double, T_float, T_int, T_String, T_undefined}, |
| /* String */ {T_undefined, T_String, T_String, T_String, T_String, T_String, T_undefined, T_String, T_String, T_String, T_String, T_String, T_String}, |
| /* null */ {T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_undefined, T_String, T_undefined}, |
| }; |
| |
| static final String[] fTypeName = new String[] {"undefined", "java.lang.Object", "char", "byte", "short", "boolean", "void", "long", "double", "float", "int", "java.lang.String", "null"}; |
| |
| static final String[] typeUpperName = new String[] {"Undefined", "Object", "Char", "Byte", "Short", "Boolean", "Void", "Long", "Double", "Float", "Int", "String", "Null"}; |
| |
| static final int Op_plus = 0; |
| static final int Op_minus = 1; |
| static final int Op_multiply = 2; |
| static final int Op_divide = 3; |
| static final int Op_remainder = 4; |
| static final int Op_greater = 5; |
| static final int Op_greaterEqual = 6; |
| static final int Op_less = 7; |
| static final int Op_lessEqual = 8; |
| static final int Op_equalEqual = 9; |
| static final int Op_notEqual = 10; |
| static final int Op_leftShift = 11; |
| static final int Op_rightShift = 12; |
| static final int Op_unsignedRightShift = 13; |
| static final int Op_or = 14; |
| static final int Op_and = 15; |
| static final int Op_xor = 16; |
| static final int Op_twiddle = 17; |
| static final int Op_not = 18; |
| static final int Op_equal = 19; |
| static final int Op_plusAss = 20; |
| static final int Op_minusAss = 21; |
| static final int Op_multiplyAss = 22; |
| static final int Op_divideAss = 23; |
| static final int Op_remainderAss = 24; |
| static final int Op_leftShiftAss = 25; |
| static final int Op_rightShiftAss = 26; |
| static final int Op_unsignedRightShiftAss = 27; |
| static final int Op_orAss = 28; |
| static final int Op_andAss = 29; |
| static final int Op_xorAss = 30; |
| static final int Op_prefixPlusPlus = 31; |
| static final int Op_postfixPlusPlus = 32; |
| static final int Op_prefixMinusMinus = 33; |
| static final int Op_postfixMinusMinus = 34; |
| |
| static final String[] opSymbol = new String[] {"+", "-", "*", "/", "%", ">", ">=", "<", "<=", "==", "!=", "<<", ">>", ">>>", "|", "&", "^", "~", "!", "=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "&=", "^=", "++", "++", "--", "--"}; |
| |
| static final String[] opName = new String[] {"plus", "minus", "multiply", "divide", "remainder", "greater", "greaterEqual", "less", "lessEqual", "equalEqual", "notEqual", "leftShift", "rightShift", "unsignedRightShift", "or", "and", "xor", "twiddle", "not", "equal", "plusAssignment", "minusAssignment", "multiplyAssignment", "divideAssignment", "remainderAssignment", "leftShiftAssignment", "rightShiftAssignment", "unsignedRightShiftAssignment", "orAssignment", "andAssignment", "xorAssignment", "prefixPlusPlus", "postfixPlusPlus", "prefixMinusMinus", "postfixMinusMinus"}; |
| |
| static final String[] opUpperName = new String[] {"Plus", "Minus", "Multiply", "Divide", "Remainder", "Greater", "GreaterEqual", "Less", "LessEqual", "EqualEqual", "NotEqual", "LeftShift", "RightShift", "UnsignedRightShift", "Or", "And", "Xor", "Twiddle", "Not", "Equal", "PlusAssignment", "MinusAssignment", "MultiplyAssignment", "DivideAssignment", "RemainderAssignment", "LeftShiftAssignment", "RightShiftAssignment", "UnsignedRightShiftAssignment", "OrAssignment", "AndAssignment", "XorAssignment", "PrefixPlusPlus", "PostfixPlusPlus", "PrefixMinusMinus", "PostfixMinusMinus"}; |
| |
| static final String[] immediate = new String[] {"x", "y"}; |
| |
| static final String[] fVariable = new String[] {"xVar", "yVar", "xArray", "yArray"}; |
| |
| static final String[] field = new String[] {"xField", "yField", "xStaticField", "yStaticField"}; |
| |
| static final String[] prefixList = new String[] {"foo.", "EvalTypeTests.", IInternalDebugCoreConstants.EMPTY_STRING}; |
| |
| /** |
| * Set the working directory of the launch configuration to generate the files |
| * in the correct package location. |
| */ |
| static public void main(String[] args) throws Exception { |
| |
| genTestsNumericTypeAllOpsAllTypes(T_byte); |
| genTestsNumericTypeAllOpsAllTypes(T_char); |
| genTestsNumericTypeAllOpsAllTypes(T_short); |
| genTestsNumericTypeAllOpsAllTypes(T_int); |
| genTestsNumericTypeAllOpsAllTypes(T_long); |
| genTestsNumericTypeAllOpsAllTypes(T_float); |
| genTestsNumericTypeAllOpsAllTypes(T_double); |
| genTestsBooleanAllOpsBoolean(); |
| genTestsStringPlusOpAllTypes(); |
| |
| genTestsLocalVarValue(); |
| |
| genTestsLocalVarAssignment(); |
| |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_byte); |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_char); |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_short); |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_int); |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_long); |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_float); |
| genTestsNumericTypeAllAssignmentOpsAllTypes(T_double); |
| genTestsBooleanAllAssignmentOpsBoolean(); |
| genTestsStringPlusAssignmentOpAllTypes(); |
| |
| genTestsNumericTypeCast(); |
| |
| genTestsAllIntegerTypesAllXfixOps(); |
| |
| genTestsQualifiedFieldValue(); |
| genTestsQualifiedStaticFieldValue(); |
| genTestsFieldValue(); |
| genTestsStaticFieldValue(); |
| |
| genTestsArrayValue(); |
| genTestsArrayAssignment(); |
| genTestsArrayAllocation(); |
| genTestsArrayInitialization(); |
| |
| System.out.println("done"); |
| |
| } |
| |
| //------------------------------- |
| |
| public static void genTestsNumericTypeAllOpsAllTypes(int type) throws Exception { |
| |
| StringBuilder code = new StringBuilder(); |
| |
| String className = typeUpperName[type] + "OperatorsTests"; |
| |
| genTestsNumericTypeArithmeticOpNumericTypes(type, Op_plus, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, Op_plus, T_String, code); |
| genTestsNumericTypeArithmeticOpNumericTypes(type, Op_minus, code); |
| genTestsNumericTypeArithmeticOpNumericTypes(type, Op_multiply, code); |
| genTestsNumericTypeArithmeticOpNumericTypes(type, Op_divide, code); |
| genTestsNumericTypeArithmeticOpNumericTypes(type, Op_remainder, code); |
| genTestsNumericTypeComparisonOpNumericTypes(type, Op_greater, code); |
| genTestsNumericTypeComparisonOpNumericTypes(type, Op_greaterEqual, code); |
| genTestsNumericTypeComparisonOpNumericTypes(type, Op_less, code); |
| genTestsNumericTypeComparisonOpNumericTypes(type, Op_lessEqual, code); |
| genTestsNumericTypeComparisonOpNumericTypes(type, Op_equalEqual, code); |
| genTestsNumericTypeComparisonOpNumericTypes(type, Op_notEqual, code); |
| if (type != T_float && type != T_double) { |
| genTestsIntegerTypeShiftOpIntegerTypes(type, Op_leftShift, code); |
| genTestsIntegerTypeShiftOpIntegerTypes(type, Op_rightShift, code); |
| genTestsIntegerTypeShiftOpIntegerTypes(type, Op_unsignedRightShift, code); |
| genTestsIntegerTypeBooleanOpIntegerTypes(type, Op_or, code); |
| genTestsIntegerTypeBooleanOpIntegerTypes(type, Op_and, code); |
| genTestsIntegerTypeBooleanOpIntegerTypes(type, Op_xor, code); |
| } |
| |
| genTestUnaryOpNumericType(type, Op_plus, code); |
| genTestUnaryOpNumericType(type, Op_minus, code); |
| if (type != T_float && type != T_double) { |
| genTestUnaryOpNumericType(type, Op_twiddle, code); |
| } |
| |
| createJavaFile(className, "EvalSimpleTests", 15, 1, true, code); |
| |
| } |
| |
| public static void genTestsBooleanAllOpsBoolean() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "BooleanOperatorsTests"; |
| |
| genTestBooleanBinaryOpBoolean(Op_or, code); |
| genTestBooleanBinaryOpBoolean(Op_and, code); |
| genTestBooleanBinaryOpBoolean(Op_xor, code); |
| genTestUnaryOpBoolean(Op_not, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 15, 1, false, code); |
| } |
| |
| public static void genTestsStringPlusOpAllTypes() throws Exception { |
| |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "StringPlusOpTests"; |
| |
| code.append("\t// " + fTypeName[T_String] + " " + opSymbol[Op_plus] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_String] + ", " + fTypeName[T_null] + "}\n" + |
| "\n"); |
| |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_byte, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_char, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_short, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_int, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_long, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_double, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_boolean, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_String, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(T_String, Op_plus, T_null, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 15, 1, true, false, code); |
| } |
| |
| public static void genTestsLocalVarValue() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "LocalVarValueTests"; |
| |
| code.append("\t// \n" + |
| "\n"); |
| |
| genTestLocalVarValue(T_byte, code); |
| genTestLocalVarValue(T_char, code); |
| genTestLocalVarValue(T_short, code); |
| genTestLocalVarValue(T_int, code); |
| genTestLocalVarValue(T_long, code); |
| genTestLocalVarValue(T_float, code); |
| genTestLocalVarValue(T_double, code); |
| genTestLocalVarValue(T_String, code); |
| genTestLocalVarValue(T_boolean, code); |
| // genTestLocalVarValue(T_null, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 37, 1, true, code); |
| } |
| |
| public static void genTestsLocalVarAssignment() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "LocalVarAssignmentTests"; |
| |
| code.append("\t// \n" + |
| "\n"); |
| |
| genTestLocalVarAssignment(T_byte, code); |
| genTestLocalVarAssignment(T_char, code); |
| genTestLocalVarAssignment(T_short, code); |
| genTestLocalVarAssignment(T_int, code); |
| genTestLocalVarAssignment(T_long, code); |
| genTestLocalVarAssignment(T_float, code); |
| genTestLocalVarAssignment(T_double, code); |
| genTestLocalVarAssignment(T_String, code); |
| genTestLocalVarAssignment(T_boolean, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 37, 1, true, code); |
| } |
| |
| public static void genTestsNumericTypeAllAssignmentOpsAllTypes(int type) throws Exception { |
| |
| StringBuilder code = new StringBuilder(); |
| |
| String className = typeUpperName[type] + "AssignmentOperatorsTests"; |
| |
| genTestsNumericTypeArithmeticAssignmentOpNumericTypes(type, Op_plusAss, code); |
| genTestsNumericTypeArithmeticAssignmentOpNumericTypes(type, Op_minusAss, code); |
| genTestsNumericTypeArithmeticAssignmentOpNumericTypes(type, Op_multiplyAss, code); |
| genTestsNumericTypeArithmeticAssignmentOpNumericTypes(type, Op_divideAss, code); |
| genTestsNumericTypeArithmeticAssignmentOpNumericTypes(type, Op_remainderAss, code); |
| if (type != T_float && type != T_double) { |
| genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(type, Op_leftShiftAss, code); |
| genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(type, Op_rightShiftAss, code); |
| genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(type, Op_unsignedRightShiftAss, code); |
| genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(type, Op_orAss, code); |
| genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(type, Op_andAss, code); |
| genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(type, Op_xorAss, code); |
| } |
| |
| |
| createJavaFile(className, "EvalSimpleTests", 37, 1, false, code); |
| |
| } |
| |
| public static void genTestsBooleanAllAssignmentOpsBoolean() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "BooleanAssignmentOperatorsTests"; |
| |
| code.append("\t// " + fTypeName[T_boolean] + " " + opSymbol[Op_orAss] + " " + fTypeName[T_boolean] + "\n" + |
| "\n"); |
| genTestTypeAssignmentOpType(T_boolean, Op_orAss, T_boolean, code); |
| |
| code.append("\t// " + fTypeName[T_boolean] + " " + opSymbol[Op_andAss] + " " + fTypeName[T_boolean] + "\n" + |
| "\n"); |
| genTestTypeAssignmentOpType(T_boolean, Op_andAss, T_boolean, code); |
| |
| code.append("\t// " + fTypeName[T_boolean] + " " + opSymbol[Op_xorAss] + " " + fTypeName[T_boolean] + "\n" + |
| "\n"); |
| genTestTypeAssignmentOpType(T_boolean, Op_xorAss, T_boolean, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 37, 1, false, code); |
| } |
| |
| public static void genTestsStringPlusAssignmentOpAllTypes() throws Exception { |
| |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "StringPlusAssignmentOpTests"; |
| |
| code.append("\t// " + fTypeName[T_String] + " " + opSymbol[Op_plusAss] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_String] + ", " + fTypeName[T_null] + "}\n" + |
| "\n"); |
| |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_byte, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_char, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_short, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_int, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_long, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_float, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_double, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_String, code); |
| genTestTypeAssignmentOpType(T_String, Op_plusAss, T_null, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 37, 1, true, false, code); |
| } |
| |
| public static void genTestsNumericTypeCast() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "NumericTypesCastTests"; |
| |
| genTestsNumericTypeCast(T_byte, code); |
| genTestsNumericTypeCast(T_char, code); |
| genTestsNumericTypeCast(T_short, code); |
| genTestsNumericTypeCast(T_int, code); |
| genTestsNumericTypeCast(T_long, code); |
| genTestsNumericTypeCast(T_float, code); |
| genTestsNumericTypeCast(T_double, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 15, 1, false, code); |
| } |
| |
| public static void genTestsAllIntegerTypesAllXfixOps() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "XfixOperatorsTests"; |
| |
| genTestsNumericTypeAllXfixOps(T_byte, code); |
| genTestsNumericTypeAllXfixOps(T_char, code); |
| genTestsNumericTypeAllXfixOps(T_short, code); |
| genTestsNumericTypeAllXfixOps(T_int, code); |
| genTestsNumericTypeAllXfixOps(T_long, code); |
| genTestsNumericTypeAllXfixOps(T_float, code); |
| genTestsNumericTypeAllXfixOps(T_double, code); |
| |
| createJavaFile(className, "EvalSimpleTests", 37, 1, false, code); |
| } |
| |
| public static void genTestsQualifiedFieldValue() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "QualifiedFieldValueTests"; |
| |
| genTestFieldValue(T_byte, 0, code); |
| genTestFieldValue(T_char, 0, code); |
| genTestFieldValue(T_short, 0, code); |
| genTestFieldValue(T_int, 0, code); |
| genTestFieldValue(T_long, 0, code); |
| genTestFieldValue(T_float, 0, code); |
| genTestFieldValue(T_double, 0, code); |
| genTestFieldValue(T_String, 0, code); |
| genTestFieldValue(T_boolean, 0, code); |
| |
| createJavaFile(className, "EvalTypeTests", 73, 1, true, code); |
| } |
| |
| public static void genTestsQualifiedStaticFieldValue() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "QualifiedStaticFieldValueTests"; |
| |
| genTestStaticFieldValue(T_byte, 0, code); |
| genTestStaticFieldValue(T_char, 0, code); |
| genTestStaticFieldValue(T_short, 0, code); |
| genTestStaticFieldValue(T_int, 0, code); |
| genTestStaticFieldValue(T_long, 0, code); |
| genTestStaticFieldValue(T_float, 0, code); |
| genTestStaticFieldValue(T_double, 0, code); |
| genTestStaticFieldValue(T_String, 0, code); |
| genTestStaticFieldValue(T_boolean, 0, code); |
| |
| createJavaFile(className, "EvalTypeTests", 73, 1, true, code); |
| |
| code = new StringBuilder(); |
| |
| className = "QualifiedStaticFieldValueTests2"; |
| |
| genTestStaticFieldValue(T_byte, 1, code); |
| genTestStaticFieldValue(T_char, 1, code); |
| genTestStaticFieldValue(T_short, 1, code); |
| genTestStaticFieldValue(T_int, 1, code); |
| genTestStaticFieldValue(T_long, 1, code); |
| genTestStaticFieldValue(T_float, 1, code); |
| genTestStaticFieldValue(T_double, 1, code); |
| genTestStaticFieldValue(T_String, 1, code); |
| genTestStaticFieldValue(T_boolean, 1, code); |
| |
| createJavaFile(className, "EvalTypeTests", 73, 1, true, code); |
| } |
| |
| public static void genTestsFieldValue() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "FieldValueTests"; |
| |
| genTestFieldValue(T_byte, 2, code); |
| genTestFieldValue(T_char, 2, code); |
| genTestFieldValue(T_short, 2, code); |
| genTestFieldValue(T_int, 2, code); |
| genTestFieldValue(T_long, 2, code); |
| genTestFieldValue(T_float, 2, code); |
| genTestFieldValue(T_double, 2, code); |
| genTestFieldValue(T_String, 2, code); |
| genTestFieldValue(T_boolean, 2, code); |
| |
| createJavaFile(className, "EvalTypeTests", 63, 2, true, code); |
| } |
| |
| public static void genTestsStaticFieldValue() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "StaticFieldValueTests"; |
| |
| genTestStaticFieldValue(T_byte, 2, code); |
| genTestStaticFieldValue(T_char, 2, code); |
| genTestStaticFieldValue(T_short, 2, code); |
| genTestStaticFieldValue(T_int, 2, code); |
| genTestStaticFieldValue(T_long, 2, code); |
| genTestStaticFieldValue(T_float, 2, code); |
| genTestStaticFieldValue(T_double, 2, code); |
| genTestStaticFieldValue(T_String, 2, code); |
| genTestStaticFieldValue(T_boolean, 2, code); |
| |
| createJavaFile(className, "EvalTypeTests", 63, 2, true, code); |
| |
| className = "StaticFieldValueTests2"; |
| |
| createJavaFile(className, "EvalTypeTests", 67, 2, true, code); |
| } |
| |
| public static void genTestsArrayValue() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "ArrayValueTests"; |
| |
| genTestArrayLength(T_byte, code); |
| genTestArrayLength(T_char, code); |
| genTestArrayLength(T_short, code); |
| genTestArrayLength(T_int, code); |
| genTestArrayLength(T_long, code); |
| genTestArrayLength(T_float, code); |
| genTestArrayLength(T_double, code); |
| genTestArrayLength(T_String, code); |
| genTestArrayLength(T_boolean, code); |
| |
| genTestArrayValue(T_byte, code); |
| genTestArrayValue(T_char, code); |
| genTestArrayValue(T_short, code); |
| genTestArrayValue(T_int, code); |
| genTestArrayValue(T_long, code); |
| genTestArrayValue(T_float, code); |
| genTestArrayValue(T_double, code); |
| genTestArrayValue(T_String, code); |
| genTestArrayValue(T_boolean, code); |
| |
| createJavaFile(className, "EvalArrayTests", 37, 1, true, code); |
| } |
| |
| public static void genTestsArrayAssignment() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "ArrayAssignmentTests"; |
| |
| genTestArrayAssignment(T_byte, code); |
| genTestArrayAssignment(T_char, code); |
| genTestArrayAssignment(T_short, code); |
| genTestArrayAssignment(T_int, code); |
| genTestArrayAssignment(T_long, code); |
| genTestArrayAssignment(T_float, code); |
| genTestArrayAssignment(T_double, code); |
| genTestArrayAssignment(T_String, code); |
| genTestArrayAssignment(T_boolean, code); |
| |
| createJavaFile(className, "EvalArrayTests", 37, 1, true, code); |
| } |
| |
| public static void genTestsArrayAllocation() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "ArrayAllocationTests"; |
| |
| genTestArrayAllocation(T_byte, code); |
| genTestArrayAllocation(T_char, code); |
| genTestArrayAllocation(T_short, code); |
| genTestArrayAllocation(T_int, code); |
| genTestArrayAllocation(T_long, code); |
| genTestArrayAllocation(T_float, code); |
| genTestArrayAllocation(T_double, code); |
| genTestArrayAllocation(T_String, code); |
| genTestArrayAllocation(T_boolean, code); |
| |
| createJavaFile(className, "EvalArrayTests", 37, 1, false, code); |
| } |
| |
| public static void genTestsArrayInitialization() throws Exception { |
| StringBuilder code = new StringBuilder(); |
| |
| String className = "ArrayInitializationTests"; |
| |
| genTestArrayInitialization(T_byte, code); |
| genTestArrayInitialization(T_char, code); |
| genTestArrayInitialization(T_short, code); |
| genTestArrayInitialization(T_int, code); |
| genTestArrayInitialization(T_long, code); |
| genTestArrayInitialization(T_float, code); |
| genTestArrayInitialization(T_double, code); |
| genTestArrayInitialization(T_String, code); |
| genTestArrayInitialization(T_boolean, code); |
| |
| createJavaFile(className, "EvalArrayTests", 37, 1, true, code); |
| } |
| //---------------------------- |
| |
| public static void genTestsNumericTypeArithmeticOpNumericTypes(int type, int op, StringBuilder code) { |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_float] + ", " + fTypeName[T_double] + "}\n" + |
| "\n"); |
| |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_byte, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_char, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_short, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_int, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_long, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_float, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_double, code); |
| |
| } |
| |
| public static void genTestsNumericTypeComparisonOpNumericTypes(int type, int op, StringBuilder code) { |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_float] + ", " + fTypeName[T_double] + "}\n" + |
| "\n"); |
| |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_byte, code); |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_char, code); |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_short, code); |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_int, code); |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_long, code); |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_float, code); |
| genTestTypeBinaryOpTypeBooleanResult(type, op, T_double, code); |
| |
| } |
| |
| public static void genTestsIntegerTypeShiftOpIntegerTypes(int type, int op, StringBuilder code) { |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + "}\n" + |
| "\n"); |
| |
| genTestTypeBinaryOpTypeUnaryPromotion(type, op, T_byte, code); |
| genTestTypeBinaryOpTypeUnaryPromotion(type, op, T_char, code); |
| genTestTypeBinaryOpTypeUnaryPromotion(type, op, T_short, code); |
| genTestTypeBinaryOpTypeUnaryPromotion(type, op, T_int, code); |
| genTestTypeBinaryOpTypeUnaryPromotion(type, op, T_long, code); |
| |
| } |
| |
| public static void genTestsIntegerTypeBooleanOpIntegerTypes(int type, int op, StringBuilder code) { |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + "}\n" + |
| "\n"); |
| |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_byte, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_char, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_short, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_int, code); |
| genTestTypeBinaryOpTypeBinaryPromotion(type, op, T_long, code); |
| |
| } |
| |
| public static void genTestsNumericTypeArithmeticAssignmentOpNumericTypes(int type, int op, StringBuilder code) { |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_float] + ", " + fTypeName[T_double] + "}\n" + |
| "\n"); |
| |
| genTestTypeAssignmentOpType(type, op, T_byte, code); |
| genTestTypeAssignmentOpType(type, op, T_char, code); |
| genTestTypeAssignmentOpType(type, op, T_short, code); |
| genTestTypeAssignmentOpType(type, op, T_int, code); |
| genTestTypeAssignmentOpType(type, op, T_long, code); |
| genTestTypeAssignmentOpType(type, op, T_float, code); |
| genTestTypeAssignmentOpType(type, op, T_double, code); |
| |
| } |
| |
| public static void genTestsIntegerTypeArithmeticAssignmentOpIntegerTypes(int type, int op, StringBuilder code) { |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_float] + ", " + fTypeName[T_double] + "}\n" + |
| "\n"); |
| |
| genTestTypeAssignmentOpType(type, op, T_byte, code); |
| genTestTypeAssignmentOpType(type, op, T_char, code); |
| genTestTypeAssignmentOpType(type, op, T_short, code); |
| genTestTypeAssignmentOpType(type, op, T_int, code); |
| genTestTypeAssignmentOpType(type, op, T_long, code); |
| |
| } |
| |
| public static void genTestsNumericTypeCast(int type, StringBuilder code) { |
| |
| code.append("\t// (" + fTypeName[type] + ") {" + fTypeName[T_byte] + ", " + fTypeName[T_char] + ", " + fTypeName[T_short] + ", " + fTypeName[T_int] + ", " + fTypeName[T_long] + ", " + fTypeName[T_float] + ", " + fTypeName[T_double] + "}\n" + |
| "\n"); |
| |
| genTestNumericTypeCast(type, T_byte, code); |
| genTestNumericTypeCast(type, T_char, code); |
| genTestNumericTypeCast(type, T_short, code); |
| genTestNumericTypeCast(type, T_int, code); |
| genTestNumericTypeCast(type, T_long, code); |
| genTestNumericTypeCast(type, T_float, code); |
| genTestNumericTypeCast(type, T_double, code); |
| |
| } |
| |
| public static void genTestsNumericTypeAllXfixOps(int type, StringBuilder code) { |
| |
| code.append("\t// {" + opSymbol[Op_prefixPlusPlus] + ", " + opSymbol[Op_prefixMinusMinus] + "} " + fTypeName[type] + "\n" + |
| "\t// " + fTypeName[type] + " {" + opSymbol[Op_postfixPlusPlus] + ", " + opSymbol[Op_postfixMinusMinus] + "}\n" + |
| "\n"); |
| |
| genTestNumericTypePrefixOp(type, Op_prefixPlusPlus, code); |
| genTestNumericTypePrefixOp(type, Op_prefixMinusMinus, code); |
| genTestNumericTypePostfixOp(type, Op_postfixPlusPlus, code); |
| genTestNumericTypePostfixOp(type, Op_postfixMinusMinus, code); |
| } |
| |
| //---------------------------- |
| |
| public static void genTestTypeBinaryOpTypeBinaryPromotion(int type1, int op, int type2, StringBuilder code) { |
| |
| int promotedType = getPromotionType(type1, type2); |
| |
| String t1UName = typeUpperName[type1]; |
| String t2UName = typeUpperName[type2]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\tpublic void test" + t1UName + oUName + t2UName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeBinaryOp(type1, op, type2, promotedType, 0, 1, true, code); |
| code.append("\n"); |
| genCodeBinaryOp(type1, op, type2, promotedType, 1, 0, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestTypeBinaryOpTypeBooleanResult(int type1, int op, int type2, StringBuilder code) { |
| |
| int promotedType = T_boolean; |
| |
| String t1UName = typeUpperName[type1]; |
| String t2UName = typeUpperName[type2]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\tpublic void test" + t1UName + oUName + t2UName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeBinaryOp(type1, op, type2, promotedType, 0, 1, true, code); |
| code.append("\n"); |
| genCodeBinaryOp(type1, op, type2, promotedType, 1, 0, false, code); |
| code.append("\n"); |
| genCodeBinaryOp(type1, op, type2, promotedType, 0, 0, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| |
| } |
| |
| public static void genTestTypeBinaryOpTypeUnaryPromotion(int type1, int op, int type2, StringBuilder code) { |
| |
| int promotedType = getUnaryPromotionType(type1); |
| |
| String t1UName = typeUpperName[type1]; |
| String t2UName = typeUpperName[type2]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\tpublic void test" + t1UName + oUName + t2UName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeBinaryOp(type1, op, type2, promotedType, 0, 1, true, code); |
| code.append("\n"); |
| genCodeBinaryOp(type1, op, type2, promotedType, 1, 0, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestBooleanBinaryOpBoolean(int op, StringBuilder code) { |
| |
| int type = T_boolean; |
| |
| String uName = typeUpperName[type]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\t// " + fTypeName[type] + " " + opSymbol[op] + " " + fTypeName[type] + "\n" + |
| "\n"); |
| |
| code.append("\tpublic void test" + uName + oUName + uName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeBinaryOp(type, op, type, type, 0, 0, true, code); |
| code.append("\n"); |
| genCodeBinaryOp(type, op, type, type, 0, 1, false, code); |
| code.append("\n"); |
| genCodeBinaryOp(type, op, type, type, 1, 0, false, code); |
| code.append("\n"); |
| genCodeBinaryOp(type, op, type, type, 1, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| |
| } |
| |
| public static void genTestUnaryOpNumericType(int type, int op, StringBuilder code) { |
| |
| int promotedType = getUnaryPromotionType(type); |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String oSymbol = opSymbol[op]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\t// " + oSymbol + " " + tName + "\n" + |
| "\n"); |
| |
| code.append("\tpublic void test" + oUName + tUName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeUnaryOp(type, op, promotedType, 0, true, code); |
| code.append("\n"); |
| genCodeUnaryOp(type, op, promotedType, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestUnaryOpBoolean(int op, StringBuilder code) { |
| |
| int type = T_boolean; |
| |
| String uName = typeUpperName[type]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\t// " + opSymbol[op] + " " + fTypeName[type] + "\n" + |
| "\n"); |
| |
| code.append("\tpublic void test" + oUName + uName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeUnaryOp(type, op, type, 0, true, code); |
| code.append("\n"); |
| genCodeUnaryOp(type, op, type, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| |
| } |
| |
| public static void genTestLocalVarValue(int type, StringBuilder code ) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeLocalVarValue(type, 0, true, code); |
| code.append("\n"); |
| genCodeLocalVarValue(type, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestLocalVarAssignment(int type, StringBuilder code) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeLocalVarAssignment(type, 0, 0, true, code); |
| code.append("\n"); |
| genCodeLocalVarAssignment(type, 0, 1, false, code); |
| code.append("\n"); |
| genCodeLocalVarAssignment(type, 1, 0, false, code); |
| code.append("\n"); |
| genCodeLocalVarAssignment(type, 1, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestTypeAssignmentOpType(int type1, int op, int type2, StringBuilder code) { |
| |
| String t1UName = typeUpperName[type1]; |
| String t2UName = typeUpperName[type2]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\tpublic void test" + t1UName + oUName + t2UName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeSetTmp("tmp" + fVariable[0], type1, Op_equal, fVariable[0] + t1UName + "Value", true, code); |
| genCodeSetTmp("tmp" + fVariable[0], type1, op, immediate[0] + t2UName + "Value", false, code); |
| genCodeAssignmentOp(type1, op, type2, 0, 0, true, code); |
| code.append("\n"); |
| genCodeSetTmp("tmp" + fVariable[0], type1, op, immediate[1] + t2UName + "Value", false, code); |
| genCodeAssignmentOp(type1, op, type2, 0, 1, false, code); |
| code.append("\n"); |
| genCodeSetTmp("tmp" + fVariable[1], type1, Op_equal, fVariable[1] + t1UName + "Value", true, code); |
| genCodeSetTmp("tmp" + fVariable[1], type1, op, immediate[0] + t2UName + "Value", false, code); |
| genCodeAssignmentOp(type1, op, type2, 1, 0, false, code); |
| code.append("\n"); |
| genCodeSetTmp("tmp" + fVariable[1], type1, op, immediate[1] + t2UName + "Value", false, code); |
| genCodeAssignmentOp(type1, op, type2, 1, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestNumericTypeCast(int type1, int type2, StringBuilder code) { |
| |
| String t1UName = typeUpperName[type1]; |
| String t2UName = typeUpperName[type2]; |
| |
| code.append("\tpublic void test" + t1UName + "Cast" + t2UName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeCast(type1, type2, 0, true, code); |
| code.append("\n"); |
| genCodeCast(type1, type2, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| |
| } |
| |
| public static void genTestNumericTypePrefixOp(int type, int op, StringBuilder code) { |
| |
| String tUName = typeUpperName[type]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\tpublic void test" + oUName + tUName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodePrefixOp(type, op, 0, true, code); |
| code.append("\n"); |
| genCodePrefixOp(type, op, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestNumericTypePostfixOp(int type, int op, StringBuilder code) { |
| |
| String tUName = typeUpperName[type]; |
| String oUName = opUpperName[op]; |
| |
| code.append("\tpublic void test" + oUName + tUName + "() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodePostfixOp(type, op, 0, true, code); |
| code.append("\n"); |
| genCodePostfixOp(type, op, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestFieldValue(int type, int prefix, StringBuilder code ) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "FieldValue() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeFieldValue(type, 0, prefix, true, code); |
| code.append("\n"); |
| genCodeFieldValue(type, 1, prefix, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestStaticFieldValue(int type, int prefix, StringBuilder code ) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "StaticFieldValue() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeFieldValue(type, 2, prefix, true, code); |
| code.append("\n"); |
| genCodeFieldValue(type, 3, prefix, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestArrayValue(int type, StringBuilder code ) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "ArrayValue() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeArrayValue(type, 2, 0, true, code); |
| code.append("\n"); |
| genCodeArrayValue(type, 2, 1, false, code); |
| code.append("\n"); |
| genCodeArrayValue(type, 2, 2, false, code); |
| code.append("\n"); |
| genCodeArrayValue(type, 3, 0, false, code); |
| code.append("\n"); |
| genCodeArrayValue(type, 3, 1, false, code); |
| code.append("\n"); |
| genCodeArrayValue(type, 3, 2, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestArrayLength(int type, StringBuilder code ) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "ArrayLength() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeArrayLength(type, 2, true, code); |
| code.append("\n"); |
| genCodeArrayLength(type, 3, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestArrayAssignment(int type, StringBuilder code ) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "ArrayAssignment() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeArrayAssignment(type, 2, 0, 0, true, code); |
| code.append("\n"); |
| genCodeArrayAssignment(type, 2, 1, 1, false, code); |
| code.append("\n"); |
| genCodeArrayAssignment(type, 2, 2, 0, false, code); |
| code.append("\n"); |
| genCodeArrayAssignment(type, 3, 0, 1, false, code); |
| code.append("\n"); |
| genCodeArrayAssignment(type, 3, 1, 0, false, code); |
| code.append("\n"); |
| genCodeArrayAssignment(type, 3, 2, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestArrayAllocation(int type, StringBuilder code) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "ArrayAllocation() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeArrayAllocation(type, 2, 0, true, code); |
| code.append("\n"); |
| genCodeArrayAllocation(type, 3, 1, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| public static void genTestArrayInitialization(int type, StringBuilder code) { |
| String tUName = typeUpperName[type]; |
| |
| code.append("\tpublic void test" + tUName + "ArrayAllocation() throws Throwable {\n"); |
| tryBlockBegin(code); |
| genCodeArrayInitialization(type, 2, true, code); |
| code.append("\n"); |
| genCodeArrayInitialization(type, 3, false, code); |
| tryBlockEnd(code); |
| code.append("\t}\n\n"); |
| } |
| |
| //------------------------------- |
| |
| public static void genCodeBinaryOp(int type1, int op, int type2, int resultType, int var1, int var2, boolean first, StringBuilder code) { |
| |
| String t1Name = fTypeName[type1]; |
| String t1UName = typeUpperName[type1]; |
| String t2Name = fTypeName[type2]; |
| String t2UName = typeUpperName[type2]; |
| String resName = fTypeName[resultType]; |
| String resUName = typeUpperName[resultType]; |
| String oName = opName[op]; |
| String oSymbol = opSymbol[op]; |
| String v1Name = immediate[var1]; |
| String v2Name = immediate[var2]; |
| |
| genCodeEval(v1Name + t1UName + " + " + oName + "Op + " + v2Name + t2UName, first, code); |
| genCodeReturnTypeCheck(t1Name + " " + oName + " " + t2Name, resName, first, code); |
| switch (resultType) { |
| case T_String: |
| genCodeReturnValueCheckStringType(t1Name + " " + oName + " " + t2Name, v1Name + t1UName + "Value " + oSymbol + " " + v2Name + t2UName + "Value", first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(t1Name + " " + oName + " " + t2Name, resName, resUName, v1Name + t1UName + "Value " + oSymbol + " " + v2Name + t2UName + "Value", first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(t1Name + " " + oName + " " + t2Name, resName, resUName, v1Name + t1UName + "Value " + oSymbol + " " + v2Name + t2UName + "Value", first, code); |
| break; |
| } |
| } |
| |
| public static void genCodeUnaryOp(int type, int op, int resultType, int var, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String resName = fTypeName[resultType]; |
| String resUName = typeUpperName[resultType]; |
| String oName = opName[op]; |
| String oSymbol = opSymbol[op]; |
| String vName = immediate[var]; |
| |
| genCodeEval(oName + "Op + " + vName + tUName, first, code); |
| genCodeReturnTypeCheck(oName + " " + tName, resName, first, code); |
| if (type == T_float || type == T_double) { |
| genCodeReturnValueCheckFloatDoubleType(oName + " " + tName, resName, resUName, oSymbol + " " + vName + tUName + "Value", first, code); |
| } else { |
| genCodeReturnValueCheckPrimitiveType(oName + " " + tName, resName, resUName, oSymbol + " " + vName + tUName + "Value", first, code); |
| } |
| } |
| |
| public static void genCodeLocalVarValue(int type, int var, boolean first, StringBuilder code) { |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| |
| genCodeLocalVarValue(type,var, vName + tUName + "Value", first, code); |
| } |
| |
| public static void genCodeLocalVarValue(int type, int var, String referenceExpression, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| |
| genCodeEval(vName + tUName, first, code); |
| genCodeReturnTypeCheck(tName + " local variable value", tName, first,code); |
| switch (type) { |
| case T_String: |
| genCodeReturnValueCheckStringType(tName + " local variable value", referenceExpression, first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(tName + " local variable value", tName, tUName, referenceExpression, first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(tName + " local variable value", tName, tUName, referenceExpression, first, code); |
| break; |
| } |
| } |
| |
| public static void genCodeLocalVarAssignment(int type, int var, int imm, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| String iName = immediate[imm]; |
| String oName = opName[Op_equal]; |
| |
| genCodeEval(vName + tUName + " + " + oName + "Op +" + iName + tUName, first, code); |
| genCodeReturnTypeCheck(tName + " local variable assignment", tName, first,code); |
| switch (type) { |
| case T_String: |
| genCodeReturnValueCheckStringType(tName + " local variable assignment", iName + tUName + "Value", first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(tName + " local variable assignment", tName, tUName, iName + tUName + "Value", first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(tName + " local variable assignment", tName, tUName, iName + tUName + "Value", first, code); |
| break; |
| } |
| genCodeLocalVarValue(type, var, iName + tUName + "Value", false, code); |
| } |
| |
| public static void genCodeAssignmentOp(int type1, int op, int type2, int var, int imm, boolean first, StringBuilder code) { |
| String t1Name = fTypeName[type1]; |
| String t1UName = typeUpperName[type1]; |
| String t2Name = fTypeName[type2]; |
| String t2UName = typeUpperName[type2]; |
| String oName = opName[op]; |
| String vName = fVariable[var]; |
| String iName = immediate[imm]; |
| |
| genCodeEval(vName + t1UName + " + " + oName + "Op + " + iName + t2UName, first, code); |
| genCodeReturnTypeCheck(t1Name + " " + oName + " " + t2Name, t1Name, first, code); |
| switch (type1) { |
| case T_String: |
| genCodeReturnValueCheckStringType(t1Name + " " + oName + " " + t2Name, "tmp" + vName, first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(t1Name + " " + oName + " " + t2Name, t1Name, t1UName, "tmp" + vName, first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(t1Name + " " + oName + " " + t2Name, t1Name, t1UName, "tmp" + vName, first, code); |
| break; |
| } |
| genCodeLocalVarValue(type1, var, "tmp" + vName, false, code); |
| } |
| |
| public static void genCodeCast(int type1, int type2, int imm, boolean first, StringBuilder code) { |
| String t1Name = fTypeName[type1]; |
| String t1UName = typeUpperName[type1]; |
| String t2Name = fTypeName[type2]; |
| String t2UName = typeUpperName[type2]; |
| String iName = immediate[imm]; |
| |
| genCodeEval("\"(" + t1Name + ")\" + " + iName + t2UName, first, code); |
| genCodeReturnTypeCheck("(" + t1Name + ") " + t2Name, t1Name, first, code); |
| if (type1 == T_float || type1 == T_double) { |
| genCodeReturnValueCheckFloatDoubleType("(" + t1Name + ") " + t2Name, t1Name, t1UName, (needCast(type1, type2) ? "( " + t1Name + ") " : IInternalDebugCoreConstants.EMPTY_STRING) + iName + t2UName + "Value", first, code); |
| } else { |
| genCodeReturnValueCheckPrimitiveType("(" + t1Name + ") " + t2Name, t1Name, t1UName, (needCast(type1, type2) ? "( " + t1Name + ") " : IInternalDebugCoreConstants.EMPTY_STRING) + iName + t2UName + "Value", first, code); |
| } |
| } |
| |
| public static void genCodePrefixOp(int type, int op, int var, boolean first, StringBuilder code) { |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| String oName = opName[op]; |
| String oSymbol = opSymbol[op]; |
| |
| genCodeSetTmp("tmp" + vName, type, Op_equal, vName + tUName + "Value", true, code); |
| genCodeEval(oName + "Op + " + vName + tUName, first, code); |
| genCodeReturnTypeCheck(oName + " " + tName, tName, first, code); |
| if (type == T_float || type == T_double) { |
| genCodeReturnValueCheckFloatDoubleType(oName + " " + tName, tName, tUName, oSymbol + "tmp" + vName, first,code); |
| } else { |
| genCodeReturnValueCheckPrimitiveType(oName + " " + tName, tName, tUName, oSymbol + "tmp" + vName, first,code); |
| } |
| genCodeLocalVarValue(type, var, "tmp" + vName, false, code); |
| } |
| |
| public static void genCodePostfixOp(int type, int op, int var, boolean first, StringBuilder code) { |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| String oName = opName[op]; |
| String oSymbol = opSymbol[op]; |
| |
| genCodeSetTmp("tmp" + vName, type, Op_equal, vName + tUName + "Value", true, code); |
| genCodeEval(vName + tUName + " + " + oName + "Op", first, code); |
| genCodeReturnTypeCheck(tName + " " + oName, tName, first, code); |
| if (type == T_float || type == T_double) { |
| genCodeReturnValueCheckFloatDoubleType(tName + " " + oName, tName, tUName, "tmp" + vName + oSymbol, first,code); |
| } else { |
| genCodeReturnValueCheckPrimitiveType(tName + " " + oName, tName, tUName, "tmp" + vName + oSymbol, first,code); |
| } |
| genCodeLocalVarValue(type, var, "tmp" + vName, false, code); |
| } |
| |
| public static void genCodeFieldValue(int type, int var, int prefix, boolean first, StringBuilder code) { |
| String tUName = typeUpperName[type]; |
| String fName = field[var]; |
| |
| genCodeFieldValue(type, var, prefix, fName + tUName + "Value", first, code); |
| } |
| |
| public static void genCodeFieldValue(int type, int var, int prefix, String referenceExpression, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String fName = field[var]; |
| String prefixVal = prefixList[prefix]; |
| |
| genCodeEval("\"" + prefixVal + "\" + " + fName + tUName, first, code); |
| genCodeReturnTypeCheck(tName + " field value", tName, first,code); |
| switch (type) { |
| case T_String: |
| genCodeReturnValueCheckStringType(tName + " field value", referenceExpression, first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(tName + " field value", tName, tUName, referenceExpression, first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(tName + " field value", tName, tUName, referenceExpression, first, code); |
| break; |
| } |
| } |
| |
| public static void genCodeArrayLength(int type, int var, boolean first, StringBuilder code) { |
| |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| |
| genCodeArrayLength(type, var, vName + tUName + "Value.length", first, code); |
| |
| } |
| |
| public static void genCodeArrayLength(int type, int var, String referenceExpression, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| |
| genCodeEval(vName + tUName + " + \".length\"", first, code); |
| genCodeReturnTypeCheck(tName + " array length", fTypeName[T_int], first,code); |
| genCodeReturnValueCheckPrimitiveType(tName + " array length", fTypeName[T_int], typeUpperName[T_int], referenceExpression, first, code); |
| } |
| |
| public static void genCodeArrayValue(int type, int var, int index, boolean first, StringBuilder code) { |
| |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| |
| genCodeArrayValue(type, var, index, vName + tUName + "Value[" + index + "]", first, code); |
| } |
| |
| public static void genCodeArrayValue(int type, int var, int index, String referenceExpression, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| |
| genCodeEval(vName + tUName + " + \"[" + index + "]\"", first, code); |
| genCodeReturnTypeCheck(tName + " array value", tName, first,code); |
| switch (type) { |
| case T_String: |
| genCodeReturnValueCheckStringType(tName + " array value", referenceExpression, first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(tName + " array value", tName, tUName, referenceExpression, first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(tName + " array value", tName, tUName, referenceExpression, first, code); |
| break; |
| } |
| } |
| |
| public static void genCodeArrayAssignment(int type, int var, int index, int imm, boolean first, StringBuilder code) { |
| |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| String iName = immediate[imm]; |
| String oName = opName[Op_equal]; |
| |
| genCodeEval(vName + tUName + " + \"[" + index + "]\" + " + oName + "Op +" + iName + tUName, first, code); |
| genCodeReturnTypeCheck(tName + " array assignment", tName, first,code); |
| switch (type) { |
| case T_String: |
| genCodeReturnValueCheckStringType(tName + " array assignment", iName + tUName + "Value", first, code); |
| break; |
| case T_float: |
| case T_double: |
| genCodeReturnValueCheckFloatDoubleType(tName + " array assignment", tName, tUName, iName + tUName + "Value", first, code); |
| break; |
| default: |
| genCodeReturnValueCheckPrimitiveType(tName + " array assignment", tName, tUName, iName + tUName + "Value", first, code); |
| break; |
| } |
| genCodeArrayValue(type, var, index, iName + tUName + "Value", false, code); |
| } |
| |
| public static void genCodeArrayAllocation(int type, int var, int dim, boolean first, StringBuilder code) { |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String charUName = typeUpperName[T_char]; |
| String vName = fVariable[var]; |
| String iName = immediate[dim]; |
| String oName = opName[Op_equal]; |
| |
| genCodeEval(vName + tUName + " + " + oName + "Op + \"new " + tName + "[\" + " + iName + charUName + " + \"]\"", first, code); |
| genCodeReturnTypeCheck(tName + " array assignment", tName + "[]", first, code); |
| if (first) { |
| genCodeSetTmp("intValue", T_int, Op_equal, "0", true, code); |
| } |
| genCodeArrayLength(type, var, iName + charUName + "Value", false, code); |
| } |
| |
| public static void genCodeArrayInitialization(int type, int var, boolean first, StringBuilder code) { |
| String tName = fTypeName[type]; |
| String tUName = typeUpperName[type]; |
| String vName = fVariable[var]; |
| String oName = opName[Op_equal]; |
| String i1Name = immediate[(var + 1) % 2]; |
| |
| String value = IInternalDebugCoreConstants.EMPTY_STRING; |
| boolean f = true; |
| for (int i = 0; i < var; i ++) { |
| if (f) { |
| f = false; |
| } else { |
| value += " + \", \" + "; |
| } |
| value += immediate[i % 2] + tUName; |
| } |
| |
| genCodeEval(vName + tUName + " + " + oName + "Op + \"new " + tName + "[]{\" + " + value + " + \"}\"", first, code); |
| genCodeReturnTypeCheck(tName + " array assignment", tName + "[]", first, code); |
| if (first) { |
| genCodeSetTmp("intValue", T_int, Op_equal, "0", true, code); |
| if (type != T_int) { |
| genCodeSetTmp(((type == T_String)? "string" : tName) + "Value", type, Op_equal, i1Name + tUName + "Value", true, code); |
| } |
| } |
| genCodeArrayLength(type, var, IInternalDebugCoreConstants.EMPTY_STRING + var, false, code); |
| for (int i = 0; i < var; i++) { |
| genCodeArrayValue(type, var, i, immediate[i % 2] + tUName + "Value", false, code); |
| } |
| } |
| |
| //---------------------------- |
| |
| public static void genCodeEval(String expression, boolean first, StringBuilder code) { |
| code.append("\t\t" + ((first)? "IValue " : IInternalDebugCoreConstants.EMPTY_STRING) + "value = eval(" + expression + ");\n"); |
| } |
| |
| public static void genCodeReturnTypeCheck(String test, String typeName, boolean first, StringBuilder code) { |
| code.append("\t\t" + ((first)? "String " : IInternalDebugCoreConstants.EMPTY_STRING) + "typeName = value.getReferenceTypeName();\n" + |
| "\t\tassertEquals(\"" + test + " : wrong type : \", \"" + typeName + "\", typeName);\n"); |
| } |
| |
| public static void genCodeReturnValueCheckPrimitiveType(String test, String resType, String uResType, String referenceExpression, boolean first, StringBuilder code) { |
| code.append("\t\t" + ((first)? resType + " " : IInternalDebugCoreConstants.EMPTY_STRING) + resType + "Value = ((IJavaPrimitiveValue)value).get" + uResType + "Value();\n" + |
| "\t\tassertEquals(\"" + test + " : wrong result : \", " + referenceExpression + ", " + resType+ "Value);\n"); |
| } |
| |
| public static void genCodeReturnValueCheckFloatDoubleType(String test, String resType, String uResType, String referenceExpression, boolean first, StringBuilder code) { |
| code.append("\t\t" + ((first)? resType + " " : IInternalDebugCoreConstants.EMPTY_STRING) + resType + "Value = ((IJavaPrimitiveValue)value).get" + uResType + "Value();\n" + |
| "\t\tassertEquals(\"" + test + " : wrong result : \", " + referenceExpression + ", " + resType+ "Value, 0);\n"); |
| } |
| |
| public static void genCodeReturnValueCheckStringType(String test, String referenceExpression, boolean first, StringBuilder code) { |
| code.append("\t\t" + ((first)? "String " : IInternalDebugCoreConstants.EMPTY_STRING) + "stringValue = ((JDIObjectValue)value).getValueString();\n" + |
| "\t\tassertEquals(\"" + test + " : wrong result : \", " + referenceExpression + ", " + "stringValue);\n"); |
| } |
| |
| /* public static void genCodeReturnValueCheckObjectType(String test, String referenceExpression, boolean first, StringBuilder code) { |
| code.append("\t\t" + ((first)? "Object " : IInternalDebugUIConstants.EMPTY_STRING) + "objectValue = ((JDIObjectValue)value).getValueString();\n" + |
| "\t\tassertEquals(\"" + test + " : wrong result : \" + " + "objectValue, " + "objectValue, " + referenceExpression + ");\n"); |
| }*/ |
| |
| public static void genCodeSetTmp(String varName, int type, int op, String value, boolean init , StringBuilder code) { |
| code.append("\t\t" + ((init)? fTypeName[type] + " " : IInternalDebugCoreConstants.EMPTY_STRING) + varName + " " + opSymbol[op] + " " + value + ";\n"); |
| } |
| |
| |
| public static void tryBlockBegin(StringBuilder code) { |
| code.append("\t\ttry {\n\t\tinit();\n"); |
| } |
| |
| public static void tryBlockEnd(StringBuilder code) { |
| code.append("\t\t} finally {\n\t\tend();\n\t\t}\n"); |
| } |
| |
| //------------------------------ |
| |
| public static void createJavaFile(String className, String testClass, int breakPointLine, int frameNumber, boolean importJDIObjectValue, StringBuilder tests) throws Exception { |
| createJavaFile(className, testClass, breakPointLine, frameNumber, importJDIObjectValue, true, tests); |
| } |
| |
| public static void createJavaFile(String className, String testClass, int breakPointLine, int frameNumber, boolean importJDIObjectValue, boolean importIJavaPrimitiveValue, StringBuilder tests) throws Exception { |
| |
| StringBuilder code = new StringBuilder(); |
| |
| code.append("/*******************************************************************************\n"); |
| code.append(" * Copyright (c) 2002, 2003 IBM Corporation and others.\n"); |
| code.append(" * All rights reserved. This program and the accompanying materials \n"); |
| code.append(" * are made available under the terms of the Eclipse Public License v1.0\n"); |
| code.append(" * which accompanies this distribution, and is available at\n"); |
| code.append(" * http://www.eclipse.org/legal/epl-v10.html\n"); |
| code.append(" * \n"); |
| code.append(" * Contributors:\n"); |
| code.append(" * IBM Corporation - initial API and implementation\n"); |
| code.append(" *******************************************************************************/\n"); |
| code.append("package org.eclipse.jdt.debug.tests.eval;\n\n" + |
| "import org.eclipse.debug.core.model.IValue;\n"); |
| |
| if (importIJavaPrimitiveValue) { |
| code.append("import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;\n"); |
| } |
| if (importJDIObjectValue) { |
| code.append("import org.eclipse.jdt.internal.debug.core.model.JDIObjectValue;\n"); |
| } |
| code.append("\n" + |
| "public class " + className + " extends Tests {\n" + |
| "\n" + |
| "\tpublic " + className + "(String arg) {\n" + |
| "\t\tsuper(arg);\n" + |
| "\t}\n" + |
| "\n" + |
| "\tprotected void init() throws Exception {\n" + |
| "\t\tinitializeFrame(\"" + testClass + "\"," + breakPointLine + "," + frameNumber + ");\n" + |
| "\t}\n" + |
| "\n" + |
| "\tprotected void end() throws Exception {\n" + |
| "\t\tdestroyFrame();\n" + |
| "\t}\n\n"); |
| |
| code.append(tests); |
| |
| code.append("\n}\n"); |
| |
| try (Writer file = new FileWriter(new File(className + ".java").getAbsoluteFile())) { |
| file.write(code.toString()); |
| } |
| |
| } |
| } |