0001: /*******************************************************************************
0002: * Copyright (c) 2000, 2006 IBM Corporation and others.
0003: * All rights reserved. This program and the accompanying materials
0004: * are made available under the terms of the Eclipse Public License v1.0
0005: * which accompanies this distribution, and is available at
0006: * http://www.eclipse.org/legal/epl-v10.html
0007: *
0008: * Contributors:
0009: * IBM Corporation - initial API and implementation
0010: * Perry James - nullStatus method improvement (165346)
0011: *******************************************************************************/package org.eclipse.jdt.internal.compiler.ast;
0012:
0013: import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
0014: import org.eclipse.jdt.internal.compiler.util.Util;
0015:
0016: public abstract class OperatorExpression extends Expression implements
0017: OperatorIds {
0018:
0019: public static int[][] OperatorSignatures = new int[NumberOfTables][];
0020:
0021: static {
0022: classInitialize();
0023: }
0024:
0025: /**
0026: * OperatorExpression constructor comment.
0027: */
0028: public OperatorExpression() {
0029: super ();
0030: }
0031:
0032: public static final void classInitialize() {
0033: OperatorSignatures[AND] = get_AND();
0034: OperatorSignatures[AND_AND] = get_AND_AND();
0035: OperatorSignatures[DIVIDE] = get_DIVIDE();
0036: OperatorSignatures[EQUAL_EQUAL] = get_EQUAL_EQUAL();
0037: OperatorSignatures[GREATER] = get_GREATER();
0038: OperatorSignatures[GREATER_EQUAL] = get_GREATER_EQUAL();
0039: OperatorSignatures[LEFT_SHIFT] = get_LEFT_SHIFT();
0040: OperatorSignatures[LESS] = get_LESS();
0041: OperatorSignatures[LESS_EQUAL] = get_LESS_EQUAL();
0042: OperatorSignatures[MINUS] = get_MINUS();
0043: OperatorSignatures[MULTIPLY] = get_MULTIPLY();
0044: OperatorSignatures[OR] = get_OR();
0045: OperatorSignatures[OR_OR] = get_OR_OR();
0046: OperatorSignatures[PLUS] = get_PLUS();
0047: OperatorSignatures[REMAINDER] = get_REMAINDER();
0048: OperatorSignatures[RIGHT_SHIFT] = get_RIGHT_SHIFT();
0049: OperatorSignatures[UNSIGNED_RIGHT_SHIFT] = get_UNSIGNED_RIGHT_SHIFT();
0050: OperatorSignatures[XOR] = get_XOR();
0051: }
0052:
0053: public static final String generateTableTestCase() {
0054: //return a String which is a java method allowing to test
0055: //the non zero entries of all tables
0056:
0057: /*
0058: org.eclipse.jdt.internal.compiler.ast.
0059: OperatorExpression.generateTableTestCase();
0060: */
0061:
0062: int[] operators = new int[] { AND, AND_AND, DIVIDE, GREATER,
0063: GREATER_EQUAL, LEFT_SHIFT, LESS, LESS_EQUAL, MINUS,
0064: MULTIPLY, OR, OR_OR, PLUS, REMAINDER, RIGHT_SHIFT,
0065: UNSIGNED_RIGHT_SHIFT, XOR };
0066:
0067: class Decode {
0068: public final String constant(int code) {
0069: switch (code) {
0070: case T_boolean:
0071: return "true"; //$NON-NLS-1$
0072: case T_byte:
0073: return "((byte) 3)"; //$NON-NLS-1$
0074: case T_char:
0075: return "'A'"; //$NON-NLS-1$
0076: case T_double:
0077: return "300.0d"; //$NON-NLS-1$
0078: case T_float:
0079: return "100.0f"; //$NON-NLS-1$
0080: case T_int:
0081: return "1"; //$NON-NLS-1$
0082: case T_long:
0083: return "7L"; //$NON-NLS-1$
0084: case T_JavaLangString:
0085: return "\"hello-world\""; //$NON-NLS-1$
0086: case T_null:
0087: return "null"; //$NON-NLS-1$
0088: case T_short:
0089: return "((short) 5)"; //$NON-NLS-1$
0090: case T_JavaLangObject:
0091: return "null";} //$NON-NLS-1$
0092: return Util.EMPTY_STRING;
0093: }
0094:
0095: public final String type(int code) {
0096: switch (code) {
0097: case T_boolean:
0098: return "z"; //$NON-NLS-1$
0099: case T_byte:
0100: return "b"; //$NON-NLS-1$
0101: case T_char:
0102: return "c"; //$NON-NLS-1$
0103: case T_double:
0104: return "d"; //$NON-NLS-1$
0105: case T_float:
0106: return "f"; //$NON-NLS-1$
0107: case T_int:
0108: return "i"; //$NON-NLS-1$
0109: case T_long:
0110: return "l"; //$NON-NLS-1$
0111: case T_JavaLangString:
0112: return "str"; //$NON-NLS-1$
0113: case T_null:
0114: return "null"; //$NON-NLS-1$
0115: case T_short:
0116: return "s"; //$NON-NLS-1$
0117: case T_JavaLangObject:
0118: return "obj";} //$NON-NLS-1$
0119: return "xxx";} //$NON-NLS-1$
0120:
0121: public final String operator(int operator) {
0122: switch (operator) {
0123: case EQUAL_EQUAL:
0124: return "=="; //$NON-NLS-1$
0125: case LESS_EQUAL:
0126: return "<="; //$NON-NLS-1$
0127: case GREATER_EQUAL:
0128: return ">="; //$NON-NLS-1$
0129: case LEFT_SHIFT:
0130: return "<<"; //$NON-NLS-1$
0131: case RIGHT_SHIFT:
0132: return ">>"; //$NON-NLS-1$
0133: case UNSIGNED_RIGHT_SHIFT:
0134: return ">>>"; //$NON-NLS-1$
0135: case OR_OR:
0136: return "||"; //$NON-NLS-1$
0137: case AND_AND:
0138: return "&&"; //$NON-NLS-1$
0139: case PLUS:
0140: return "+"; //$NON-NLS-1$
0141: case MINUS:
0142: return "-"; //$NON-NLS-1$
0143: case NOT:
0144: return "!"; //$NON-NLS-1$
0145: case REMAINDER:
0146: return "%"; //$NON-NLS-1$
0147: case XOR:
0148: return "^"; //$NON-NLS-1$
0149: case AND:
0150: return "&"; //$NON-NLS-1$
0151: case MULTIPLY:
0152: return "*"; //$NON-NLS-1$
0153: case OR:
0154: return "|"; //$NON-NLS-1$
0155: case TWIDDLE:
0156: return "~"; //$NON-NLS-1$
0157: case DIVIDE:
0158: return "/"; //$NON-NLS-1$
0159: case GREATER:
0160: return ">"; //$NON-NLS-1$
0161: case LESS:
0162: return "<";} //$NON-NLS-1$
0163: return "????";} //$NON-NLS-1$
0164: }
0165:
0166: Decode decode = new Decode();
0167: String s;
0168:
0169: s = "\tpublic static void binaryOperationTablesTestCase(){\n" + //$NON-NLS-1$
0170:
0171: "\t\t//TC test : all binary operation (described in tables)\n"
0172: + //$NON-NLS-1$
0173: "\t\t//method automatically generated by\n"
0174: + //$NON-NLS-1$
0175: "\t\t//org.eclipse.jdt.internal.compiler.ast.OperatorExpression.generateTableTestCase();\n"
0176: + //$NON-NLS-1$
0177:
0178: "\t\tString str0;\t String str\t= "
0179: + decode.constant(T_JavaLangString)
0180: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0181: "\t\tint i0;\t int i\t= "
0182: + decode.constant(T_int)
0183: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0184: "\t\tboolean z0;\t boolean z\t= "
0185: + decode.constant(T_boolean)
0186: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0187: "\t\tchar c0; \t char c\t= "
0188: + decode.constant(T_char)
0189: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0190: "\t\tfloat f0; \t float f\t= "
0191: + decode.constant(T_float)
0192: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0193: "\t\tdouble d0;\t double d\t= "
0194: + decode.constant(T_double)
0195: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0196: "\t\tbyte b0; \t byte b\t= "
0197: + decode.constant(T_byte)
0198: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0199: "\t\tshort s0; \t short s\t= "
0200: + decode.constant(T_short)
0201: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0202: "\t\tlong l0; \t long l\t= "
0203: + decode.constant(T_long)
0204: + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0205: "\t\tObject obj0; \t Object obj\t= "
0206: + decode.constant(T_JavaLangObject) + ";\n" + //$NON-NLS-1$ //$NON-NLS-2$
0207: "\n"; //$NON-NLS-1$
0208:
0209: int error = 0;
0210: for (int i = 0; i < operators.length; i++) {
0211: int operator = operators[i];
0212: for (int left = 0; left < 16; left++)
0213: for (int right = 0; right < 16; right++) {
0214: int result = (OperatorSignatures[operator][(left << 4)
0215: + right]) & 0x0000F;
0216: if (result != T_undefined)
0217:
0218: //1/ First regular computation then 2/ comparaison
0219: //with a compile time constant (generated by the compiler)
0220: // z0 = s >= s;
0221: // if ( z0 != (((short) 5) >= ((short) 5)))
0222: // System.out.println(155);
0223:
0224: {
0225: s += "\t\t" + decode.type(result) + "0" + " = " + decode.type(left); //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$
0226: s += " " + decode.operator(operator) + " " + decode.type(right) + ";\n"; //$NON-NLS-2$ //$NON-NLS-1$ //$NON-NLS-3$
0227: String begin = result == T_JavaLangString ? "\t\tif (! " : "\t\tif ( "; //$NON-NLS-2$ //$NON-NLS-1$
0228: String test = result == T_JavaLangString ? ".equals(" : " != ("; //$NON-NLS-2$ //$NON-NLS-1$
0229: s += begin + decode.type(result) + "0" + test //$NON-NLS-1$
0230: + decode.constant(left) + " " //$NON-NLS-1$
0231: + decode.operator(operator) + " " //$NON-NLS-1$
0232: + decode.constant(right) + "))\n"; //$NON-NLS-1$
0233: s += "\t\t\tSystem.out.println(" + (++error) + ");\n"; //$NON-NLS-1$ //$NON-NLS-2$
0234:
0235: }
0236: }
0237: }
0238:
0239: return s += "\n\t\tSystem.out.println(\"binary tables test : done\");}"; //$NON-NLS-1$
0240: }
0241:
0242: public static final int[] get_AND() {
0243:
0244: //the code is an int, only 20 bits are used, see below.
0245: // (cast) left Op (cast) rigth --> result
0246: // 0000 0000 0000 0000 0000
0247: // <<16 <<12 <<8 <<4
0248:
0249: int[] table = new int[16 * 16];
0250:
0251: // table[(T_undefined<<4)+T_undefined] = T_undefined;
0252: // table[(T_undefined<<4)+T_byte] = T_undefined;
0253: // table[(T_undefined<<4)+T_long] = T_undefined;
0254: // table[(T_undefined<<4)+T_short] = T_undefined;
0255: // table[(T_undefined<<4)+T_void] = T_undefined;
0256: // table[(T_undefined<<4)+T_String] = T_undefined;
0257: // table[(T_undefined<<4)+T_Object] = T_undefined;
0258: // table[(T_undefined<<4)+T_double] = T_undefined;
0259: // table[(T_undefined<<4)+T_float] = T_undefined;
0260: // table[(T_undefined<<4)+T_boolean] = T_undefined;
0261: // table[(T_undefined<<4)+T_char] = T_undefined;
0262: // table[(T_undefined<<4)+T_int] = T_undefined;
0263: // table[(T_undefined<<4)+T_null] = T_undefined;
0264:
0265: // table[(T_byte<<4)+T_undefined] = T_undefined;
0266: table[(T_byte << 4) + T_byte] = (Byte2Int << 12)
0267: + (Byte2Int << 4) + T_int;
0268: table[(T_byte << 4) + T_long] = (Byte2Long << 12)
0269: + (Long2Long << 4) + T_long;
0270: table[(T_byte << 4) + T_short] = (Byte2Int << 12)
0271: + (Short2Int << 4) + T_int;
0272: // table[(T_byte<<4)+T_void] = T_undefined;
0273: // table[(T_byte<<4)+T_String] = T_undefined;
0274: // table[(T_byte<<4)+T_Object] = T_undefined;
0275: // table[(T_byte<<4)+T_double] = T_undefined;
0276: // table[(T_byte<<4)+T_float] = T_undefined;
0277: // table[(T_byte<<4)+T_boolean] = T_undefined;
0278: table[(T_byte << 4) + T_char] = (Byte2Int << 12)
0279: + (Char2Int << 4) + T_int;
0280: table[(T_byte << 4) + T_int] = (Byte2Int << 12)
0281: + (Int2Int << 4) + T_int;
0282: // table[(T_byte<<4)+T_null] = T_undefined;
0283:
0284: // table[(T_long<<4)+T_undefined] = T_undefined;
0285: table[(T_long << 4) + T_byte] = (Long2Long << 12)
0286: + (Byte2Long << 4) + T_long;
0287: table[(T_long << 4) + T_long] = (Long2Long << 12)
0288: + (Long2Long << 4) + T_long;
0289: table[(T_long << 4) + T_short] = (Long2Long << 12)
0290: + (Short2Long << 4) + T_long;
0291: // table[(T_long<<4)+T_void] = T_undefined;
0292: // table[(T_long<<4)+T_String] = T_undefined;
0293: // table[(T_long<<4)+T_Object] = T_undefined;
0294: // table[(T_long<<4)+T_double] = T_undefined;
0295: // table[(T_long<<4)+T_float] = T_undefined;
0296: // table[(T_long<<4)+T_boolean] = T_undefined;
0297: table[(T_long << 4) + T_char] = (Long2Long << 12)
0298: + (Char2Long << 4) + T_long;
0299: table[(T_long << 4) + T_int] = (Long2Long << 12)
0300: + (Int2Long << 4) + T_long;
0301: // table[(T_long<<4)+T_null] = T_undefined;
0302:
0303: // table[(T_short<<4)+T_undefined] = T_undefined;
0304: table[(T_short << 4) + T_byte] = (Short2Int << 12)
0305: + (Byte2Int << 4) + T_int;
0306: table[(T_short << 4) + T_long] = (Short2Long << 12)
0307: + (Long2Long << 4) + T_long;
0308: table[(T_short << 4) + T_short] = (Short2Int << 12)
0309: + (Short2Int << 4) + T_int;
0310: // table[(T_short<<4)+T_void] = T_undefined;
0311: // table[(T_short<<4)+T_String] = T_undefined;
0312: // table[(T_short<<4)+T_Object] = T_undefined;
0313: // table[(T_short<<4)+T_double] = T_undefined;
0314: // table[(T_short<<4)+T_float] = T_undefined;
0315: // table[(T_short<<4)+T_boolean] = T_undefined;
0316: table[(T_short << 4) + T_char] = (Short2Int << 12)
0317: + (Char2Int << 4) + T_int;
0318: table[(T_short << 4) + T_int] = (Short2Int << 12)
0319: + (Int2Int << 4) + T_int;
0320: // table[(T_short<<4)+T_null] = T_undefined;
0321:
0322: // table[(T_void<<4)+T_undefined] = T_undefined;
0323: // table[(T_void<<4)+T_byte] = T_undefined;
0324: // table[(T_void<<4)+T_long] = T_undefined;
0325: // table[(T_void<<4)+T_short] = T_undefined;
0326: // table[(T_void<<4)+T_void] = T_undefined;
0327: // table[(T_void<<4)+T_String] = T_undefined;
0328: // table[(T_void<<4)+T_Object] = T_undefined;
0329: // table[(T_void<<4)+T_double] = T_undefined;
0330: // table[(T_void<<4)+T_float] = T_undefined;
0331: // table[(T_void<<4)+T_boolean] = T_undefined;
0332: // table[(T_void<<4)+T_char] = T_undefined;
0333: // table[(T_void<<4)+T_int] = T_undefined;
0334: // table[(T_void<<4)+T_null] = T_undefined;
0335:
0336: // table[(T_String<<4)+T_undefined] = T_undefined;
0337: // table[(T_String<<4)+T_byte] = T_undefined;
0338: // table[(T_String<<4)+T_long] = T_undefined;
0339: // table[(T_String<<4)+T_short] = T_undefined;
0340: // table[(T_String<<4)+T_void] = T_undefined;
0341: // table[(T_String<<4)+T_String] = T_undefined;
0342: // table[(T_String<<4)+T_Object] = T_undefined;
0343: // table[(T_String<<4)+T_double] = T_undefined;
0344: // table[(T_String<<4)+T_float] = T_undefined;
0345: // table[(T_String<<4)+T_boolean] = T_undefined;
0346: // table[(T_String<<4)+T_char] = T_undefined;
0347: // table[(T_String<<4)+T_int] = T_undefined;
0348: // table[(T_String<<4)+T_null] = T_undefined;
0349:
0350: // table[(T_Object<<4)+T_undefined] = T_undefined;
0351: // table[(T_Object<<4)+T_byte] = T_undefined;
0352: // table[(T_Object<<4)+T_long] = T_undefined;
0353: // table[(T_Object<<4)+T_short] = T_undefined;
0354: // table[(T_Object<<4)+T_void] = T_undefined;
0355: // table[(T_Object<<4)+T_String] = T_undefined;
0356: // table[(T_Object<<4)+T_Object] = T_undefined;
0357: // table[(T_Object<<4)+T_double] = T_undefined;
0358: // table[(T_Object<<4)+T_float] = T_undefined;
0359: // table[(T_Object<<4)+T_boolean] = T_undefined;
0360: // table[(T_Object<<4)+T_char] = T_undefined;
0361: // table[(T_Object<<4)+T_int] = T_undefined;
0362: // table[(T_Object<<4)+T_null] = T_undefined;
0363:
0364: // table[(T_double<<4)+T_undefined] = T_undefined;
0365: // table[(T_double<<4)+T_byte] = T_undefined;
0366: // table[(T_double<<4)+T_long] = T_undefined;
0367: // table[(T_double<<4)+T_short] = T_undefined;
0368: // table[(T_double<<4)+T_void] = T_undefined;
0369: // table[(T_double<<4)+T_String] = T_undefined;
0370: // table[(T_double<<4)+T_Object] = T_undefined;
0371: // table[(T_double<<4)+T_double] = T_undefined;
0372: // table[(T_double<<4)+T_float] = T_undefined;
0373: // table[(T_double<<4)+T_boolean] = T_undefined;
0374: // table[(T_double<<4)+T_char] = T_undefined;
0375: // table[(T_double<<4)+T_int] = T_undefined;
0376: // table[(T_double<<4)+T_null] = T_undefined;
0377:
0378: // table[(T_float<<4)+T_undefined] = T_undefined;
0379: // table[(T_float<<4)+T_byte] = T_undefined;
0380: // table[(T_float<<4)+T_long] = T_undefined;
0381: // table[(T_float<<4)+T_short] = T_undefined;
0382: // table[(T_float<<4)+T_void] = T_undefined;
0383: // table[(T_float<<4)+T_String] = T_undefined;
0384: // table[(T_float<<4)+T_Object] = T_undefined;
0385: // table[(T_float<<4)+T_double] = T_undefined;
0386: // table[(T_float<<4)+T_float] = T_undefined;
0387: // table[(T_float<<4)+T_boolean] = T_undefined;
0388: // table[(T_float<<4)+T_char] = T_undefined;
0389: // table[(T_float<<4)+T_int] = T_undefined;
0390: // table[(T_float<<4)+T_null] = T_undefined;
0391:
0392: // table[(T_boolean<<4)+T_undefined] = T_undefined;
0393: // table[(T_boolean<<4)+T_byte] = T_undefined;
0394: // table[(T_boolean<<4)+T_long] = T_undefined;
0395: // table[(T_boolean<<4)+T_short] = T_undefined;
0396: // table[(T_boolean<<4)+T_void] = T_undefined;
0397: // table[(T_boolean<<4)+T_String] = T_undefined;
0398: // table[(T_boolean<<4)+T_Object] = T_undefined;
0399: // table[(T_boolean<<4)+T_double] = T_undefined;
0400: // table[(T_boolean<<4)+T_float] = T_undefined;
0401: table[(T_boolean << 4) + T_boolean] = (Boolean2Boolean << 12)
0402: + (Boolean2Boolean << 4) + T_boolean;
0403: // table[(T_boolean<<4)+T_char] = T_undefined;
0404: // table[(T_boolean<<4)+T_int] = T_undefined;
0405: // table[(T_boolean<<4)+T_null] = T_undefined;
0406:
0407: // table[(T_char<<4)+T_undefined] = T_undefined;
0408: table[(T_char << 4) + T_byte] = (Char2Int << 12)
0409: + (Byte2Int << 4) + T_int;
0410: table[(T_char << 4) + T_long] = (Char2Long << 12)
0411: + (Long2Long << 4) + T_long;
0412: table[(T_char << 4) + T_short] = (Char2Int << 12)
0413: + (Short2Int << 4) + T_int;
0414: // table[(T_char<<4)+T_void] = T_undefined;
0415: // table[(T_char<<4)+T_String] = T_undefined;
0416: // table[(T_char<<4)+T_Object] = T_undefined;
0417: // table[(T_char<<4)+T_double] = T_undefined;
0418: // table[(T_char<<4)+T_float] = T_undefined;
0419: // table[(T_char<<4)+T_boolean] = T_undefined;
0420: table[(T_char << 4) + T_char] = (Char2Int << 12)
0421: + (Char2Int << 4) + T_int;
0422: table[(T_char << 4) + T_int] = (Char2Int << 12)
0423: + (Int2Int << 4) + T_int;
0424: // table[(T_char<<4)+T_null] = T_undefined;
0425:
0426: // table[(T_int<<4)+T_undefined] = T_undefined;
0427: table[(T_int << 4) + T_byte] = (Int2Int << 12)
0428: + (Byte2Int << 4) + T_int;
0429: table[(T_int << 4) + T_long] = (Int2Long << 12)
0430: + (Long2Long << 4) + T_long;
0431: table[(T_int << 4) + T_short] = (Int2Int << 12)
0432: + (Short2Int << 4) + T_int;
0433: // table[(T_int<<4)+T_void] = T_undefined;
0434: // table[(T_int<<4)+T_String] = T_undefined;
0435: // table[(T_int<<4)+T_Object] = T_undefined;
0436: // table[(T_int<<4)+T_double] = T_undefined;
0437: // table[(T_int<<4)+T_float] = T_undefined;
0438: // table[(T_int<<4)+T_boolean] = T_undefined;
0439: table[(T_int << 4) + T_char] = (Int2Int << 12)
0440: + (Char2Int << 4) + T_int;
0441: table[(T_int << 4) + T_int] = (Int2Int << 12) + (Int2Int << 4)
0442: + T_int;
0443: // table[(T_int<<4)+T_null] = T_undefined;
0444:
0445: // table[(T_null<<4)+T_undefined] = T_undefined;
0446: // table[(T_null<<4)+T_byte] = T_undefined;
0447: // table[(T_null<<4)+T_long] = T_undefined;
0448: // table[(T_null<<4)+T_short] = T_undefined;
0449: // table[(T_null<<4)+T_void] = T_undefined;
0450: // table[(T_null<<4)+T_String] = T_undefined;
0451: // table[(T_null<<4)+T_Object] = T_undefined;
0452: // table[(T_null<<4)+T_double] = T_undefined;
0453: // table[(T_null<<4)+T_float] = T_undefined;
0454: // table[(T_null<<4)+T_boolean] = T_undefined;
0455: // table[(T_null<<4)+T_char] = T_undefined;
0456: // table[(T_null<<4)+T_int] = T_undefined;
0457: // table[(T_null<<4)+T_null] = T_undefined;
0458:
0459: return table;
0460: }
0461:
0462: public static final int[] get_AND_AND() {
0463:
0464: //the code is an int
0465: // (cast) left Op (cast) rigth --> result
0466: // 0000 0000 0000 0000 0000
0467: // <<16 <<12 <<8 <<4
0468:
0469: int[] table = new int[16 * 16];
0470:
0471: // table[(T_undefined<<4)+T_undefined] = T_undefined;
0472: // table[(T_undefined<<4)+T_byte] = T_undefined;
0473: // table[(T_undefined<<4)+T_long] = T_undefined;
0474: // table[(T_undefined<<4)+T_short] = T_undefined;
0475: // table[(T_undefined<<4)+T_void] = T_undefined;
0476: // table[(T_undefined<<4)+T_String] = T_undefined;
0477: // table[(T_undefined<<4)+T_Object] = T_undefined;
0478: // table[(T_undefined<<4)+T_double] = T_undefined;
0479: // table[(T_undefined<<4)+T_float] = T_undefined;
0480: // table[(T_undefined<<4)+T_boolean] = T_undefined;
0481: // table[(T_undefined<<4)+T_char] = T_undefined;
0482: // table[(T_undefined<<4)+T_int] = T_undefined;
0483: // table[(T_undefined<<4)+T_null] = T_undefined;
0484:
0485: // table[(T_byte<<4)+T_undefined] = T_undefined;
0486: // table[(T_byte<<4)+T_byte] = T_undefined;
0487: // table[(T_byte<<4)+T_long] = T_undefined;
0488: // table[(T_byte<<4)+T_short] = T_undefined;
0489: // table[(T_byte<<4)+T_void] = T_undefined;
0490: // table[(T_byte<<4)+T_String] = T_undefined;
0491: // table[(T_byte<<4)+T_Object] = T_undefined;
0492: // table[(T_byte<<4)+T_double] = T_undefined;
0493: // table[(T_byte<<4)+T_float] = T_undefined;
0494: // table[(T_byte<<4)+T_boolean] = T_undefined;
0495: // table[(T_byte<<4)+T_char] = T_undefined;
0496: // table[(T_byte<<4)+T_int] = T_undefined;
0497: // table[(T_byte<<4)+T_null] = T_undefined;
0498:
0499: // table[(T_long<<4)+T_undefined] = T_undefined;
0500: // table[(T_long<<4)+T_byte] = T_undefined;
0501: // table[(T_long<<4)+T_long] = T_undefined;
0502: // table[(T_long<<4)+T_short] = T_undefined;
0503: // table[(T_long<<4)+T_void] = T_undefined;
0504: // table[(T_long<<4)+T_String] = T_undefined;
0505: // table[(T_long<<4)+T_Object] = T_undefined;
0506: // table[(T_long<<4)+T_double] = T_undefined;
0507: // table[(T_long<<4)+T_float] = T_undefined;
0508: // table[(T_long<<4)+T_boolean] = T_undefined;
0509: // table[(T_long<<4)+T_char] = T_undefined;
0510: // table[(T_long<<4)+T_int] = T_undefined;
0511: // table[(T_long<<4)+T_null] = T_undefined;
0512:
0513: // table[(T_short<<4)+T_undefined] = T_undefined;
0514: // table[(T_short<<4)+T_byte] = T_undefined;
0515: // table[(T_short<<4)+T_long] = T_undefined;
0516: // table[(T_short<<4)+T_short] = T_undefined;
0517: // table[(T_short<<4)+T_void] = T_undefined;
0518: // table[(T_short<<4)+T_String] = T_undefined;
0519: // table[(T_short<<4)+T_Object] = T_undefined;
0520: // table[(T_short<<4)+T_double] = T_undefined;
0521: // table[(T_short<<4)+T_float] = T_undefined;
0522: // table[(T_short<<4)+T_boolean] = T_undefined;
0523: // table[(T_short<<4)+T_char] = T_undefined;
0524: // table[(T_short<<4)+T_int] = T_undefined;
0525: // table[(T_short<<4)+T_null] = T_undefined;
0526:
0527: // table[(T_void<<4)+T_undefined] = T_undefined;
0528: // table[(T_void<<4)+T_byte] = T_undefined;
0529: // table[(T_void<<4)+T_long] = T_undefined;
0530: // table[(T_void<<4)+T_short] = T_undefined;
0531: // table[(T_void<<4)+T_void] = T_undefined;
0532: // table[(T_void<<4)+T_String] = T_undefined;
0533: // table[(T_void<<4)+T_Object] = T_undefined;
0534: // table[(T_void<<4)+T_double] = T_undefined;
0535: // table[(T_void<<4)+T_float] = T_undefined;
0536: // table[(T_void<<4)+T_boolean] = T_undefined;
0537: // table[(T_void<<4)+T_char] = T_undefined;
0538: // table[(T_void<<4)+T_int] = T_undefined;
0539: // table[(T_void<<4)+T_null] = T_undefined;
0540:
0541: // table[(T_String<<4)+T_undefined] = T_undefined;
0542: // table[(T_String<<4)+T_byte] = T_undefined;
0543: // table[(T_String<<4)+T_long] = T_undefined;
0544: // table[(T_String<<4)+T_short] = T_undefined;
0545: // table[(T_String<<4)+T_void] = T_undefined;
0546: // table[(T_String<<4)+T_String] = T_undefined;
0547: // table[(T_String<<4)+T_Object] = T_undefined;
0548: // table[(T_String<<4)+T_double] = T_undefined;
0549: // table[(T_String<<4)+T_float] = T_undefined;
0550: // table[(T_String<<4)+T_boolean] = T_undefined;
0551: // table[(T_String<<4)+T_char] = T_undefined;
0552: // table[(T_String<<4)+T_int] = T_undefined;
0553: // table[(T_String<<4)+T_null] = T_undefined;
0554:
0555: // table[(T_Object<<4)+T_undefined] = T_undefined;
0556: // table[(T_Object<<4)+T_byte] = T_undefined;
0557: // table[(T_Object<<4)+T_long] = T_undefined;
0558: // table[(T_Object<<4)+T_short] = T_undefined;
0559: // table[(T_Object<<4)+T_void] = T_undefined;
0560: // table[(T_Object<<4)+T_String] = T_undefined;
0561: // table[(T_Object<<4)+T_Object] = T_undefined;
0562: // table[(T_Object<<4)+T_double] = T_undefined;
0563: // table[(T_Object<<4)+T_float] = T_undefined;
0564: // table[(T_Object<<4)+T_boolean] = T_undefined;
0565: // table[(T_Object<<4)+T_char] = T_undefined;
0566: // table[(T_Object<<4)+T_int] = T_undefined;
0567: // table[(T_Object<<4)+T_null] = T_undefined;
0568:
0569: // table[(T_double<<4)+T_undefined] = T_undefined;
0570: // table[(T_double<<4)+T_byte] = T_undefined;
0571: // table[(T_double<<4)+T_long] = T_undefined;
0572: // table[(T_double<<4)+T_short] = T_undefined;
0573: // table[(T_double<<4)+T_void] = T_undefined;
0574: // table[(T_double<<4)+T_String] = T_undefined;
0575: // table[(T_double<<4)+T_Object] = T_undefined;
0576: // table[(T_double<<4)+T_double] = T_undefined;
0577: // table[(T_double<<4)+T_float] = T_undefined;
0578: // table[(T_double<<4)+T_boolean] = T_undefined;
0579: // table[(T_double<<4)+T_char] = T_undefined;
0580: // table[(T_double<<4)+T_int] = T_undefined;
0581: // table[(T_double<<4)+T_null] = T_undefined;
0582:
0583: // table[(T_float<<4)+T_undefined] = T_undefined;
0584: // table[(T_float<<4)+T_byte] = T_undefined;
0585: // table[(T_float<<4)+T_long] = T_undefined;
0586: // table[(T_float<<4)+T_short] = T_undefined;
0587: // table[(T_float<<4)+T_void] = T_undefined;
0588: // table[(T_float<<4)+T_String] = T_undefined;
0589: // table[(T_float<<4)+T_Object] = T_undefined;
0590: // table[(T_float<<4)+T_double] = T_undefined;
0591: // table[(T_float<<4)+T_float] = T_undefined;
0592: // table[(T_float<<4)+T_boolean] = T_undefined;
0593: // table[(T_float<<4)+T_char] = T_undefined;
0594: // table[(T_float<<4)+T_int] = T_undefined;
0595: // table[(T_float<<4)+T_null] = T_undefined;
0596:
0597: // table[(T_boolean<<4)+T_undefined] = T_undefined;
0598: // table[(T_boolean<<4)+T_byte] = T_undefined;
0599: // table[(T_boolean<<4)+T_long] = T_undefined;
0600: // table[(T_boolean<<4)+T_short] = T_undefined;
0601: // table[(T_boolean<<4)+T_void] = T_undefined;
0602: // table[(T_boolean<<4)+T_String] = T_undefined;
0603: // table[(T_boolean<<4)+T_Object] = T_undefined;
0604: // table[(T_boolean<<4)+T_double] = T_undefined;
0605: // table[(T_boolean<<4)+T_float] = T_undefined;
0606: table[(T_boolean << 4) + T_boolean] = (Boolean2Boolean << 12)
0607: + (Boolean2Boolean << 4) + T_boolean;
0608: // table[(T_boolean<<4)+T_char] = T_undefined;
0609: // table[(T_boolean<<4)+T_int] = T_undefined;
0610: // table[(T_boolean<<4)+T_null] = T_undefined;
0611:
0612: // table[(T_char<<4)+T_undefined] = T_undefined;
0613: // table[(T_char<<4)+T_byte] = T_undefined;
0614: // table[(T_char<<4)+T_long] = T_undefined;
0615: // table[(T_char<<4)+T_short] = T_undefined;
0616: // table[(T_char<<4)+T_void] = T_undefined;
0617: // table[(T_char<<4)+T_String] = T_undefined;
0618: // table[(T_char<<4)+T_Object] = T_undefined;
0619: // table[(T_char<<4)+T_double] = T_undefined;
0620: // table[(T_char<<4)+T_float] = T_undefined;
0621: // table[(T_char<<4)+T_boolean] = T_undefined;
0622: // table[(T_char<<4)+T_char] = T_undefined;
0623: // table[(T_char<<4)+T_int] = T_undefined;
0624: // table[(T_char<<4)+T_null] = T_undefined;
0625:
0626: // table[(T_int<<4)+T_undefined] = T_undefined;
0627: // table[(T_int<<4)+T_byte] = T_undefined;
0628: // table[(T_int<<4)+T_long] = T_undefined;
0629: // table[(T_int<<4)+T_short] = T_undefined;
0630: // table[(T_int<<4)+T_void] = T_undefined;
0631: // table[(T_int<<4)+T_String] = T_undefined;
0632: // table[(T_int<<4)+T_Object] = T_undefined;
0633: // table[(T_int<<4)+T_double] = T_undefined;
0634: // table[(T_int<<4)+T_float] = T_undefined;
0635: // table[(T_int<<4)+T_boolean] = T_undefined;
0636: // table[(T_int<<4)+T_char] = T_undefined;
0637: // table[(T_int<<4)+T_int] = T_undefined;
0638: // table[(T_int<<4)+T_null] = T_undefined;
0639:
0640: // table[(T_null<<4)+T_undefined] = T_undefined;
0641: // table[(T_null<<4)+T_byte] = T_undefined;
0642: // table[(T_null<<4)+T_long] = T_undefined;
0643: // table[(T_null<<4)+T_short] = T_undefined;
0644: // table[(T_null<<4)+T_void] = T_undefined;
0645: // table[(T_null<<4)+T_String] = T_undefined;
0646: // table[(T_null<<4)+T_Object] = T_undefined;
0647: // table[(T_null<<4)+T_double] = T_undefined;
0648: // table[(T_null<<4)+T_float] = T_undefined;
0649: // table[(T_null<<4)+T_boolean] = T_undefined;
0650: // table[(T_null<<4)+T_char] = T_undefined;
0651: // table[(T_null<<4)+T_int] = T_undefined;
0652: // table[(T_null<<4)+T_null] = T_undefined;
0653: return table;
0654: }
0655:
0656: public static final int[] get_DIVIDE() {
0657:
0658: //the code is an int
0659: // (cast) left Op (cast) rigth --> result
0660: // 0000 0000 0000 0000 0000
0661: // <<16 <<12 <<8 <<4
0662:
0663: // int[] table = new int[16*16];
0664:
0665: return get_MINUS();
0666: }
0667:
0668: public static final int[] get_EQUAL_EQUAL() {
0669:
0670: //the code is an int
0671: // (cast) left Op (cast) rigth --> result
0672: // 0000 0000 0000 0000 0000
0673: // <<16 <<12 <<8 <<4
0674:
0675: int[] table = new int[16 * 16];
0676:
0677: // table[(T_undefined<<4)+T_undefined] = T_undefined;
0678: // table[(T_undefined<<4)+T_byte] = T_undefined;
0679: // table[(T_undefined<<4)+T_long] = T_undefined;
0680: // table[(T_undefined<<4)+T_short] = T_undefined;
0681: // table[(T_undefined<<4)+T_void] = T_undefined;
0682: // table[(T_undefined<<4)+T_String] = T_undefined;
0683: // table[(T_undefined<<4)+T_Object] = T_undefined;
0684: // table[(T_undefined<<4)+T_double] = T_undefined;
0685: // table[(T_undefined<<4)+T_float] = T_undefined;
0686: // table[(T_undefined<<4)+T_boolean] = T_undefined;
0687: // table[(T_undefined<<4)+T_char] = T_undefined;
0688: // table[(T_undefined<<4)+T_int] = T_undefined;
0689: // table[(T_undefined<<4)+T_null] = T_undefined;
0690:
0691: // table[(T_byte<<4)+T_undefined] = T_undefined;
0692: table[(T_byte << 4) + T_byte] = (Byte2Int << 12)
0693: + (Byte2Int << 4) + T_boolean;
0694: table[(T_byte << 4) + T_long] = (Byte2Long << 12)
0695: + (Long2Long << 4) + T_boolean;
0696: table[(T_byte << 4) + T_short] = (Byte2Int << 12)
0697: + (Short2Int << 4) + T_boolean;
0698: // table[(T_byte<<4)+T_void] = T_undefined;
0699: // table[(T_byte<<4)+T_String] = T_undefined;
0700: // table[(T_byte<<4)+T_Object] = T_undefined;
0701: table[(T_byte << 4) + T_double] = (Byte2Double << 12)
0702: + (Double2Double << 4) + T_boolean;
0703: table[(T_byte << 4) + T_float] = (Byte2Float << 12)
0704: + (Float2Float << 4) + T_boolean;
0705: // table[(T_byte<<4)+T_boolean] = T_undefined;
0706: table[(T_byte << 4) + T_char] = (Byte2Int << 12)
0707: + (Char2Int << 4) + T_boolean;
0708: table[(T_byte << 4) + T_int] = (Byte2Int << 12)
0709: + (Int2Int << 4) + T_boolean;
0710: // table[(T_byte<<4)+T_null] = T_undefined;
0711:
0712: // table[(T_long<<4)+T_undefined] = T_undefined;
0713: table[(T_long << 4) + T_byte] = (Long2Long << 12)
0714: + (Byte2Long << 4) + T_boolean;
0715: table[(T_long << 4) + T_long] = (Long2Long << 12)
0716: + (Long2Long << 4) + T_boolean;
0717: table[(T_long << 4) + T_short] = (Long2Long << 12)
0718: + (Short2Long << 4) + T_boolean;
0719: // table[(T_long<<4)+T_void] = T_undefined;
0720: // table[(T_long<<4)+T_String] = T_undefined;
0721: // table[(T_long<<4)+T_Object] = T_undefined;
0722: table[(T_long << 4) + T_double] = (Long2Double << 12)
0723: + (Double2Double << 4) + T_boolean;
0724: table[(T_long << 4) + T_float] = (Long2Float << 12)
0725: + (Float2Float << 4) + T_boolean;
0726: // table[(T_long<<4)+T_boolean] = T_undefined;
0727: table[(T_long << 4) + T_char] = (Long2Long << 12)
0728: + (Char2Long << 4) + T_boolean;
0729: table[(T_long << 4) + T_int] = (Long2Long << 12)
0730: + (Int2Long << 4) + T_boolean;
0731: // table[(T_long<<4)+T_null] = T_undefined;
0732:
0733: // table[(T_short<<4)+T_undefined] = T_undefined;
0734: table[(T_short << 4) + T_byte] = (Short2Int << 12)
0735: + (Byte2Int << 4) + T_boolean;
0736: table[(T_short << 4) + T_long] = (Short2Long << 12)
0737: + (Long2Long << 4) + T_boolean;
0738: table[(T_short << 4) + T_short] = (Short2Int << 12)
0739: + (Short2Int << 4) + T_boolean;
0740: // table[(T_short<<4)+T_void] = T_undefined;
0741: // table[(T_short<<4)+T_String] = T_undefined;
0742: // table[(T_short<<4)+T_Object] = T_undefined;
0743: table[(T_short << 4) + T_double] = (Short2Double << 12)
0744: + (Double2Double << 4) + T_boolean;
0745: table[(T_short << 4) + T_float] = (Short2Float << 12)
0746: + (Float2Float << 4) + T_boolean;
0747: // table[(T_short<<4)+T_boolean] = T_undefined;
0748: table[(T_short << 4) + T_char] = (Short2Int << 12)
0749: + (Char2Int << 4) + T_boolean;
0750: table[(T_short << 4) + T_int] = (Short2Int << 12)
0751: + (Int2Int << 4) + T_boolean;
0752: // table[(T_short<<4)+T_null] = T_undefined;
0753:
0754: // table[(T_void<<4)+T_undefined] = T_undefined;
0755: // table[(T_void<<4)+T_byte] = T_undefined;
0756: // table[(T_void<<4)+T_long] = T_undefined;
0757: // table[(T_void<<4)+T_short] = T_undefined;
0758: // table[(T_void<<4)+T_void] = T_undefined;
0759: // table[(T_void<<4)+T_String] = T_undefined;
0760: // table[(T_void<<4)+T_Object] = T_undefined;
0761: // table[(T_void<<4)+T_double] = T_undefined;
0762: // table[(T_void<<4)+T_float] = T_undefined;
0763: // table[(T_void<<4)+T_boolean] = T_undefined;
0764: // table[(T_void<<4)+T_char] = T_undefined;
0765: // table[(T_void<<4)+T_int] = T_undefined;
0766: // table[(T_void<<4)+T_null] = T_undefined;
0767:
0768: // table[(T_String<<4)+T_undefined] = T_undefined;
0769: // table[(T_String<<4)+T_byte] = T_undefined;
0770: // table[(T_String<<4)+T_long] = T_undefined;
0771: // table[(T_String<<4)+T_short] = T_undefined;
0772: // table[(T_String<<4)+T_void] = T_undefined;
0773: table[(T_JavaLangString << 4) + T_JavaLangString] = /*String2Object String2Object*/
0774: (T_JavaLangObject << 16) + (T_JavaLangString << 12)
0775: + (T_JavaLangObject << 8) + (T_JavaLangString << 4)
0776: + T_boolean;
0777: table[(T_JavaLangString << 4) + T_JavaLangObject] = /*String2Object Object2Object*/
0778: (T_JavaLangObject << 16) + (T_JavaLangString << 12)
0779: + (T_JavaLangObject << 8) + (T_JavaLangObject << 4)
0780: + T_boolean;
0781: // table[(T_String<<4)+T_double] = T_undefined;
0782: // table[(T_String<<4)+T_float] = T_undefined;
0783: // table[(T_String<<4)+T_boolean] = T_undefined;
0784: // table[(T_String<<4)+T_char] = T_undefined;
0785: // table[(T_String<<4)+T_int] = T_undefined;
0786: table[(T_JavaLangString << 4) + T_null] = /*Object2String null2Object */
0787: (T_JavaLangObject << 16) + (T_JavaLangString << 12)
0788: + (T_JavaLangObject << 8) + (T_null << 4) + T_boolean;
0789:
0790: // table[(T_Object<<4)+T_undefined] = T_undefined;
0791: // table[(T_Object<<4)+T_byte] = T_undefined;
0792: // table[(T_Object<<4)+T_long] = T_undefined;
0793: // table[(T_Object<<4)+T_short] = T_undefined;
0794: // table[(T_Object<<4)+T_void] = T_undefined;
0795: table[(T_JavaLangObject << 4) + T_JavaLangString] = /*Object2Object String2Object*/
0796: (T_JavaLangObject << 16) + (T_JavaLangObject << 12)
0797: + (T_JavaLangObject << 8) + (T_JavaLangString << 4)
0798: + T_boolean;
0799: table[(T_JavaLangObject << 4) + T_JavaLangObject] = /*Object2Object Object2Object*/
0800: (T_JavaLangObject << 16) + (T_JavaLangObject << 12)
0801: + (T_JavaLangObject << 8) + (T_JavaLangObject << 4)
0802: + T_boolean;
0803: // table[(T_Object<<4)+T_double] = T_undefined;
0804: // table[(T_Object<<4)+T_float] = T_undefined;
0805: // table[(T_Object<<4)+T_boolean] = T_undefined;
0806: // table[(T_Object<<4)+T_char] = T_undefined;
0807: // table[(T_Object<<4)+T_int] = T_undefined;
0808: table[(T_JavaLangObject << 4) + T_null] = /*Object2Object null2Object*/
0809: (T_JavaLangObject << 16) + (T_JavaLangObject << 12)
0810: + (T_JavaLangObject << 8) + (T_null << 4) + T_boolean;
0811:
0812: // table[(T_double<<4)+T_undefined] = T_undefined;
0813: table[(T_double << 4) + T_byte] = (Double2Double << 12)
0814: + (Byte2Double << 4) + T_boolean;
0815: table[(T_double << 4) + T_long] = (Double2Double << 12)
0816: + (Long2Double << 4) + T_boolean;
0817: table[(T_double << 4) + T_short] = (Double2Double << 12)
0818: + (Short2Double << 4) + T_boolean;
0819: // table[(T_double<<4)+T_void] = T_undefined;
0820: // table[(T_double<<4)+T_String] = T_undefined;
0821: // table[(T_double<<4)+T_Object] = T_undefined;
0822: table[(T_double << 4) + T_double] = (Double2Double << 12)
0823: + (Double2Double << 4) + T_boolean;
0824: table[(T_double << 4) + T_float] = (Double2Double << 12)
0825: + (Float2Double << 4) + T_boolean;
0826: // table[(T_double<<4)+T_boolean] = T_undefined;
0827: table[(T_double << 4) + T_char] = (Double2Double << 12)
0828: + (Char2Double << 4) + T_boolean;
0829: table[(T_double << 4) + T_int] = (Double2Double << 12)
0830: + (Int2Double << 4) + T_boolean;
0831: // table[(T_double<<4)+T_null] = T_undefined;
0832:
0833: // table[(T_float<<4)+T_undefined] = T_undefined;
0834: table[(T_float << 4) + T_byte] = (Float2Float << 12)
0835: + (Byte2Float << 4) + T_boolean;
0836: table[(T_float << 4) + T_long] = (Float2Float << 12)
0837: + (Long2Float << 4) + T_boolean;
0838: table[(T_float << 4) + T_short] = (Float2Float << 12)
0839: + (Short2Float << 4) + T_boolean;
0840: // table[(T_float<<4)+T_void] = T_undefined;
0841: // table[(T_float<<4)+T_String] = T_undefined;
0842: // table[(T_float<<4)+T_Object] = T_undefined;
0843: table[(T_float << 4) + T_double] = (Float2Double << 12)
0844: + (Double2Double << 4) + T_boolean;
0845: table[(T_float << 4) + T_float] = (Float2Float << 12)
0846: + (Float2Float << 4) + T_boolean;
0847: // table[(T_float<<4)+T_boolean] = T_undefined;
0848: table[(T_float << 4) + T_char] = (Float2Float << 12)
0849: + (Char2Float << 4) + T_boolean;
0850: table[(T_float << 4) + T_int] = (Float2Float << 12)
0851: + (Int2Float << 4) + T_boolean;
0852: // table[(T_float<<4)+T_null] = T_undefined;
0853:
0854: // table[(T_boolean<<4)+T_undefined] = T_undefined;
0855: // table[(T_boolean<<4)+T_byte] = T_undefined;
0856: // table[(T_boolean<<4)+T_long] = T_undefined;
0857: // table[(T_boolean<<4)+T_short] = T_undefined;
0858: // table[(T_boolean<<4)+T_void] = T_undefined;
0859: // table[(T_boolean<<4)+T_String] = T_undefined;
0860: // table[(T_boolean<<4)+T_Object] = T_undefined;
0861: // table[(T_boolean<<4)+T_double] = T_undefined;
0862: // table[(T_boolean<<4)+T_float] = T_undefined;
0863: table[(T_boolean << 4) + T_boolean] = (Boolean2Boolean << 12)
0864: + (Boolean2Boolean << 4) + T_boolean;
0865: // table[(T_boolean<<4)+T_char] = T_undefined;
0866: // table[(T_boolean<<4)+T_int] = T_undefined;
0867: // table[(T_boolean<<4)+T_null] = T_undefined;
0868:
0869: // table[(T_char<<4)+T_undefined] = T_undefined;
0870: table[(T_char << 4) + T_byte] = (Char2Int << 12)
0871: + (Byte2Int << 4) + T_boolean;
0872: table[(T_char << 4) + T_long] = (Char2Long << 12)
0873: + (Long2Long << 4) + T_boolean;
0874: table[(T_char << 4) + T_short] = (Char2Int << 12)
0875: + (Short2Int << 4) + T_boolean;
0876: // table[(T_char<<4)+T_void] = T_undefined;
0877: // table[(T_char<<4)+T_String] = T_undefined;
0878: // table[(T_char<<4)+T_Object] = T_undefined;
0879: table[(T_char << 4) + T_double] = (Char2Double << 12)
0880: + (Double2Double << 4) + T_boolean;
0881: table[(T_char << 4) + T_float] = (Char2Float << 12)
0882: + (Float2Float << 4) + T_boolean;
0883: // table[(T_char<<4)+T_boolean] = T_undefined;
0884: table[(T_char << 4) + T_char] = (Char2Int << 12)
0885: + (Char2Int << 4) + T_boolean;
0886: table[(T_char << 4) + T_int] = (Char2Int << 12)
0887: + (Int2Int << 4) + T_boolean;
0888: // table[(T_char<<4)+T_null] = T_undefined;
0889:
0890: // table[(T_int<<4)+T_undefined] = T_undefined;
0891: table[(T_int << 4) + T_byte] = (Int2Int << 12)
0892: + (Byte2Int << 4) + T_boolean;
0893: table[(T_int << 4) + T_long] = (Int2Long << 12)
0894: + (Long2Long << 4) + T_boolean;
0895: table[(T_int << 4) + T_short] = (Int2Int << 12)
0896: + (Short2Int << 4) + T_boolean;
0897: // table[(T_int<<4)+T_void] = T_undefined;
0898: // table[(T_int<<4)+T_String] = T_undefined;
0899: // table[(T_int<<4)+T_Object] = T_undefined;
0900: table[(T_int << 4) + T_double] = (Int2Double << 12)
0901: + (Double2Double << 4) + T_boolean;
0902: table[(T_int << 4) + T_float] = (Int2Float << 12)
0903: + (Float2Float << 4) + T_boolean;
0904: // table[(T_int<<4)+T_boolean] = T_undefined;
0905: table[(T_int << 4) + T_char] = (Int2Int << 12)
0906: + (Char2Int << 4) + T_boolean;
0907: table[(T_int << 4) + T_int] = (Int2Int << 12) + (Int2Int << 4)
0908: + T_boolean;
0909: // table[(T_int<<4)+T_null] = T_undefined;
0910:
0911: // table[(T_null<<4)+T_undefined] = T_undefined;
0912: // table[(T_null<<4)+T_byte] = T_undefined;
0913: // table[(T_null<<4)+T_long] = T_undefined;
0914: // table[(T_null<<4)+T_short] = T_undefined;
0915: // table[(T_null<<4)+T_void] = T_undefined;
0916: table[(T_null << 4) + T_JavaLangString] = /*null2Object String2Object*/
0917: (T_JavaLangObject << 16) + (T_null << 12)
0918: + (T_JavaLangObject << 8) + (T_JavaLangString << 4)
0919: + T_boolean;
0920: table[(T_null << 4) + T_JavaLangObject] = /*null2Object Object2Object*/
0921: (T_JavaLangObject << 16) + (T_null << 12)
0922: + (T_JavaLangObject << 8) + (T_JavaLangObject << 4)
0923: + T_boolean;
0924: // table[(T_null<<4)+T_double] = T_undefined;
0925: // table[(T_null<<4)+T_float] = T_undefined;
0926: // table[(T_null<<4)+T_boolean] = T_undefined;
0927: // table[(T_null<<4)+T_char] = T_undefined;
0928: // table[(T_null<<4)+T_int] = T_undefined;
0929: table[(T_null << 4) + T_null] = /*null2Object null2Object*/
0930: (T_JavaLangObject << 16) + (T_null << 12)
0931: + (T_JavaLangObject << 8) + (T_null << 4) + T_boolean;
0932: return table;
0933: }
0934:
0935: public static final int[] get_GREATER() {
0936:
0937: //the code is an int
0938: // (cast) left Op (cast) rigth --> result
0939: // 0000 0000 0000 0000 0000
0940: // <<16 <<12 <<8 <<4
0941:
0942: // int[] table = new int[16*16];
0943: return get_LESS();
0944: }
0945:
0946: public static final int[] get_GREATER_EQUAL() {
0947:
0948: //the code is an int
0949: // (cast) left Op (cast) rigth --> result
0950: // 0000 0000 0000 0000 0000
0951: // <<16 <<12 <<8 <<4
0952:
0953: // int[] table = new int[16*16];
0954: return get_LESS();
0955: }
0956:
0957: public static final int[] get_LEFT_SHIFT() {
0958:
0959: //the code is an int
0960: // (cast) left Op (cast) rigth --> result
0961: // 0000 0000 0000 0000 0000
0962: // <<16 <<12 <<8 <<4
0963:
0964: int[] table = new int[16 * 16];
0965:
0966: // table[(T_undefined<<4)+T_undefined] = T_undefined;
0967: // table[(T_undefined<<4)+T_byte] = T_undefined;
0968: // table[(T_undefined<<4)+T_long] = T_undefined;
0969: // table[(T_undefined<<4)+T_short] = T_undefined;
0970: // table[(T_undefined<<4)+T_void] = T_undefined;
0971: // table[(T_undefined<<4)+T_String] = T_undefined;
0972: // table[(T_undefined<<4)+T_Object] = T_undefined;
0973: // table[(T_undefined<<4)+T_double] = T_undefined;
0974: // table[(T_undefined<<4)+T_float] = T_undefined;
0975: // table[(T_undefined<<4)+T_boolean] = T_undefined;
0976: // table[(T_undefined<<4)+T_char] = T_undefined;
0977: // table[(T_undefined<<4)+T_int] = T_undefined;
0978: // table[(T_undefined<<4)+T_null] = T_undefined;
0979:
0980: // table[(T_byte<<4)+T_undefined] = T_undefined;
0981: table[(T_byte << 4) + T_byte] = (Byte2Int << 12)
0982: + (Byte2Int << 4) + T_int;
0983: table[(T_byte << 4) + T_long] = (Byte2Int << 12)
0984: + (Long2Int << 4) + T_int;
0985: table[(T_byte << 4) + T_short] = (Byte2Int << 12)
0986: + (Short2Int << 4) + T_int;
0987: // table[(T_byte<<4)+T_void] = T_undefined;
0988: // table[(T_byte<<4)+T_String] = T_undefined;
0989: // table[(T_byte<<4)+T_Object] = T_undefined;
0990: // table[(T_byte<<4)+T_double] = T_undefined;
0991: // table[(T_byte<<4)+T_float] = T_undefined;
0992: // table[(T_byte<<4)+T_boolean] = T_undefined;
0993: table[(T_byte << 4) + T_char] = (Byte2Int << 12)
0994: + (Char2Int << 4) + T_int;
0995: table[(T_byte << 4) + T_int] = (Byte2Int << 12)
0996: + (Int2Int << 4) + T_int;
0997: // table[(T_byte<<4)+T_null] = T_undefined;
0998:
0999: // table[(T_long<<4)+T_undefined] = T_undefined;
1000: table[(T_long << 4) + T_byte] = (Long2Long << 12)
1001: + (Byte2Int << 4) + T_long;
1002: table[(T_long << 4) + T_long] = (Long2Long << 12)
1003: + (Long2Int << 4) + T_long;
1004: table[(T_long << 4) + T_short] = (Long2Long << 12)
1005: + (Short2Int << 4) + T_long;
1006: // table[(T_long<<4)+T_void] = T_undefined;
1007: // table[(T_long<<4)+T_String] = T_undefined;
1008: // table[(T_long<<4)+T_Object] = T_undefined;
1009: // table[(T_long<<4)+T_double] = T_undefined;
1010: // table[(T_long<<4)+T_float] = T_undefined;
1011: // table[(T_long<<4)+T_boolean] = T_undefined;
1012: table[(T_long << 4) + T_char] = (Long2Long << 12)
1013: + (Char2Int << 4) + T_long;
1014: table[(T_long << 4) + T_int] = (Long2Long << 12)
1015: + (Int2Int << 4) + T_long;
1016: // table[(T_long<<4)+T_null] = T_undefined;
1017:
1018: // table[(T_short<<4)+T_undefined] = T_undefined;
1019: table[(T_short << 4) + T_byte] = (Short2Int << 12)
1020: + (Byte2Int << 4) + T_int;
1021: table[(T_short << 4) + T_long] = (Short2Int << 12)
1022: + (Long2Int << 4) + T_int;
1023: table[(T_short << 4) + T_short] = (Short2Int << 12)
1024: + (Short2Int << 4) + T_int;
1025: // table[(T_short<<4)+T_void] = T_undefined;
1026: // table[(T_short<<4)+T_String] = T_undefined;
1027: // table[(T_short<<4)+T_Object] = T_undefined;
1028: // table[(T_short<<4)+T_double] = T_undefined;
1029: // table[(T_short<<4)+T_float] = T_undefined;
1030: // table[(T_short<<4)+T_boolean] = T_undefined;
1031: table[(T_short << 4) + T_char] = (Short2Int << 12)
1032: + (Char2Int << 4) + T_int;
1033: table[(T_short << 4) + T_int] = (Short2Int << 12)
1034: + (Int2Int << 4) + T_int;
1035: // table[(T_short<<4)+T_null] = T_undefined;
1036:
1037: // table[(T_void<<4)+T_undefined] = T_undefined;
1038: // table[(T_void<<4)+T_byte] = T_undefined;
1039: // table[(T_void<<4)+T_long] = T_undefined;
1040: // table[(T_void<<4)+T_short] = T_undefined;
1041: // table[(T_void<<4)+T_void] = T_undefined;
1042: // table[(T_void<<4)+T_String] = T_undefined;
1043: // table[(T_void<<4)+T_Object] = T_undefined;
1044: // table[(T_void<<4)+T_double] = T_undefined;
1045: // table[(T_void<<4)+T_float] = T_undefined;
1046: // table[(T_void<<4)+T_boolean] = T_undefined;
1047: // table[(T_void<<4)+T_char] = T_undefined;
1048: // table[(T_void<<4)+T_int] = T_undefined;
1049: // table[(T_void<<4)+T_null] = T_undefined;
1050:
1051: // table[(T_String<<4)+T_undefined] = T_undefined;
1052: // table[(T_String<<4)+T_byte] = T_undefined;
1053: // table[(T_String<<4)+T_long] = T_undefined;
1054: // table[(T_String<<4)+T_short] = T_undefined;
1055: // table[(T_String<<4)+T_void] = T_undefined;
1056: // table[(T_String<<4)+T_String] = T_undefined;
1057: // table[(T_String<<4)+T_Object] = T_undefined;
1058: // table[(T_String<<4)+T_double] = T_undefined;
1059: // table[(T_String<<4)+T_float] = T_undefined;
1060: // table[(T_String<<4)+T_boolean] = T_undefined;
1061: // table[(T_String<<4)+T_char] = T_undefined;
1062: // table[(T_String<<4)+T_int] = T_undefined;
1063: // table[(T_String<<4)+T_null] = T_undefined;
1064:
1065: // table[(T_Object<<4)+T_undefined] = T_undefined;
1066: // table[(T_Object<<4)+T_byte] = T_undefined;
1067: // table[(T_Object<<4)+T_long] = T_undefined;
1068: // table[(T_Object<<4)+T_short] = T_undefined;
1069: // table[(T_Object<<4)+T_void] = T_undefined;
1070: // table[(T_Object<<4)+T_String] = T_undefined;
1071: // table[(T_Object<<4)+T_Object] = T_undefined;
1072: // table[(T_Object<<4)+T_double] = T_undefined;
1073: // table[(T_Object<<4)+T_float] = T_undefined;
1074: // table[(T_Object<<4)+T_boolean] = T_undefined;
1075: // table[(T_Object<<4)+T_char] = T_undefined;
1076: // table[(T_Object<<4)+T_int] = T_undefined;
1077: // table[(T_Object<<4)+T_null] = T_undefined;
1078:
1079: // table[(T_double<<4)+T_undefined] = T_undefined;
1080: // table[(T_double<<4)+T_byte] = T_undefined;
1081: // table[(T_double<<4)+T_long] = T_undefined;
1082: // table[(T_double<<4)+T_short] = T_undefined;
1083: // table[(T_double<<4)+T_void] = T_undefined;
1084: // table[(T_double<<4)+T_String] = T_undefined;
1085: // table[(T_double<<4)+T_Object] = T_undefined;
1086: // table[(T_double<<4)+T_double] = T_undefined;
1087: // table[(T_double<<4)+T_float] = T_undefined;
1088: // table[(T_double<<4)+T_boolean] = T_undefined;
1089: // table[(T_double<<4)+T_char] = T_undefined;
1090: // table[(T_double<<4)+T_int] = T_undefined;
1091: // table[(T_double<<4)+T_null] = T_undefined;
1092:
1093: // table[(T_float<<4)+T_undefined] = T_undefined;
1094: // table[(T_float<<4)+T_byte] = T_undefined;
1095: // table[(T_float<<4)+T_long] = T_undefined;
1096: // table[(T_float<<4)+T_short] = T_undefined;
1097: // table[(T_float<<4)+T_void] = T_undefined;
1098: // table[(T_float<<4)+T_String] = T_undefined;
1099: // table[(T_float<<4)+T_Object] = T_undefined;
1100: // table[(T_float<<4)+T_double] = T_undefined;
1101: // table[(T_float<<4)+T_float] = T_undefined;
1102: // table[(T_float<<4)+T_boolean] = T_undefined;
1103: // table[(T_float<<4)+T_char] = T_undefined;
1104: // table[(T_float<<4)+T_int] = T_undefined;
1105: // table[(T_float<<4)+T_null] = T_undefined;
1106:
1107: // table[(T_boolean<<4)+T_undefined] = T_undefined;
1108: // table[(T_boolean<<4)+T_byte] = T_undefined;
1109: // table[(T_boolean<<4)+T_long] = T_undefined;
1110: // table[(T_boolean<<4)+T_short] = T_undefined;
1111: // table[(T_boolean<<4)+T_void] = T_undefined;
1112: // table[(T_boolean<<4)+T_String] = T_undefined;
1113: // table[(T_boolean<<4)+T_Object] = T_undefined;
1114: // table[(T_boolean<<4)+T_double] = T_undefined;
1115: // table[(T_boolean<<4)+T_float] = T_undefined;
1116: // table[(T_boolean<<4)+T_boolean] = T_undefined;
1117: // table[(T_boolean<<4)+T_char] = T_undefined;
1118: // table[(T_boolean<<4)+T_int] = T_undefined;
1119: // table[(T_boolean<<4)+T_null] = T_undefined;
1120:
1121: // table[(T_char<<4)+T_undefined] = T_undefined;
1122: table[(T_char << 4) + T_byte] = (Char2Int << 12)
1123: + (Byte2Int << 4) + T_int;
1124: table[(T_char << 4) + T_long] = (Char2Int << 12)
1125: + (Long2Int << 4) + T_int;
1126: table[(T_char << 4) + T_short] = (Char2Int << 12)
1127: + (Short2Int << 4) + T_int;
1128: // table[(T_char<<4)+T_void] = T_undefined;
1129: // table[(T_char<<4)+T_String] = T_undefined;
1130: // table[(T_char<<4)+T_Object] = T_undefined;
1131: // table[(T_char<<4)+T_double] = T_undefined;
1132: // table[(T_char<<4)+T_float] = T_undefined;
1133: // table[(T_char<<4)+T_boolean] = T_undefined;
1134: table[(T_char << 4) + T_char] = (Char2Int << 12)
1135: + (Char2Int << 4) + T_int;
1136: table[(T_char << 4) + T_int] = (Char2Int << 12)
1137: + (Int2Int << 4) + T_int;
1138: // table[(T_char<<4)+T_null] = T_undefined;
1139:
1140: // table[(T_int<<4)+T_undefined] = T_undefined;
1141: table[(T_int << 4) + T_byte] = (Int2Int << 12)
1142: + (Byte2Int << 4) + T_int;
1143: table[(T_int << 4) + T_long] = (Int2Int << 12)
1144: + (Long2Int << 4) + T_int;
1145: table[(T_int << 4) + T_short] = (Int2Int << 12)
1146: + (Short2Int << 4) + T_int;
1147: // table[(T_int<<4)+T_void] = T_undefined;
1148: // table[(T_int<<4)+T_String] = T_undefined;
1149: // table[(T_int<<4)+T_Object] = T_undefined;
1150: // table[(T_int<<4)+T_double] = T_undefined;
1151: // table[(T_int<<4)+T_float] = T_undefined;
1152: // table[(T_int<<4)+T_boolean] = T_undefined;
1153: table[(T_int << 4) + T_char] = (Int2Int << 12)
1154: + (Char2Int << 4) + T_int;
1155: table[(T_int << 4) + T_int] = (Int2Int << 12) + (Int2Int << 4)
1156: + T_int;
1157: // table[(T_int<<4)+T_null] = T_undefined;
1158:
1159: // table[(T_null<<4)+T_undefined] = T_undefined;
1160: // table[(T_null<<4)+T_byte] = T_undefined;
1161: // table[(T_null<<4)+T_long] = T_undefined;
1162: // table[(T_null<<4)+T_short] = T_undefined;
1163: // table[(T_null<<4)+T_void] = T_undefined;
1164: // table[(T_null<<4)+T_String] = T_undefined;
1165: // table[(T_null<<4)+T_Object] = T_undefined;
1166: // table[(T_null<<4)+T_double] = T_undefined;
1167: // table[(T_null<<4)+T_float] = T_undefined;
1168: // table[(T_null<<4)+T_boolean] = T_undefined;
1169: // table[(T_null<<4)+T_char] = T_undefined;
1170: // table[(T_null<<4)+T_int] = T_undefined;
1171: // table[(T_null<<4)+T_null] = T_undefined;
1172:
1173: return table;
1174: }
1175:
1176: public static final int[] get_LESS() {
1177:
1178: //the code is an int
1179: // (cast) left Op (cast) rigth --> result
1180: // 0000 0000 0000 0000 0000
1181: // <<16 <<12 <<8 <<4
1182:
1183: int[] table = new int[16 * 16];
1184:
1185: // table[(T_undefined<<4)+T_undefined] = T_undefined;
1186: // table[(T_undefined<<4)+T_byte] = T_undefined;
1187: // table[(T_undefined<<4)+T_long] = T_undefined;
1188: // table[(T_undefined<<4)+T_short] = T_undefined;
1189: // table[(T_undefined<<4)+T_void] = T_undefined;
1190: // table[(T_undefined<<4)+T_String] = T_undefined;
1191: // table[(T_undefined<<4)+T_Object] = T_undefined;
1192: // table[(T_undefined<<4)+T_double] = T_undefined;
1193: // table[(T_undefined<<4)+T_float] = T_undefined;
1194: // table[(T_undefined<<4)+T_boolean] = T_undefined;
1195: // table[(T_undefined<<4)+T_char] = T_undefined;
1196: // table[(T_undefined<<4)+T_int] = T_undefined;
1197: // table[(T_undefined<<4)+T_null] = T_undefined;
1198:
1199: // table[(T_byte<<4)+T_undefined] = T_undefined;
1200: table[(T_byte << 4) + T_byte] = (Byte2Int << 12)
1201: + (Byte2Int << 4) + T_boolean;
1202: table[(T_byte << 4) + T_long] = (Byte2Long << 12)
1203: + (Long2Long << 4) + T_boolean;
1204: table[(T_byte << 4) + T_short] = (Byte2Int << 12)
1205: + (Short2Int << 4) + T_boolean;
1206: // table[(T_byte<<4)+T_void] = T_undefined;
1207: // table[(T_byte<<4)+T_String] = T_undefined;
1208: // table[(T_byte<<4)+T_Object] = T_undefined;
1209: table[(T_byte << 4) + T_double] = (Byte2Double << 12)
1210: + (Double2Double << 4) + T_boolean;
1211: table[(T_byte << 4) + T_float] = (Byte2Float << 12)
1212: + (Float2Float << 4) + T_boolean;
1213: // table[(T_byte<<4)+T_boolean] = T_undefined;
1214: table[(T_byte << 4) + T_char] = (Byte2Int << 12)
1215: + (Char2Int << 4) + T_boolean;
1216: table[(T_byte << 4) + T_int] = (Byte2Int << 12)
1217: + (Int2Int << 4) + T_boolean;
1218: // table[(T_byte<<4)+T_null] = T_undefined;
1219:
1220: // table[(T_long<<4)+T_undefined] = T_undefined;
1221: table[(T_long << 4) + T_byte] = (Long2Long << 12)
1222: + (Byte2Long << 4) + T_boolean;
1223: table[(T_long << 4) + T_long] = (Long2Long << 12)
1224: + (Long2Long << 4) + T_boolean;
1225: table[(T_long << 4) + T_short] = (Long2Long << 12)
1226: + (Short2Long << 4) + T_boolean;
1227: // table[(T_long<<4)+T_void] = T_undefined;
1228: // table[(T_long<<4)+T_String] = T_undefined;
1229: // table[(T_long<<4)+T_Object] = T_undefined;
1230: table[(T_long << 4) + T_double] = (Long2Double << 12)
1231: + (Double2Double << 4) + T_boolean;
1232: table[(T_long << 4) + T_float] = (Long2Float << 12)
1233: + (Float2Float << 4) + T_boolean;
1234: // table[(T_long<<4)+T_boolean] = T_undefined;
1235: table[(T_long << 4) + T_char] = (Long2Long << 12)
1236: + (Char2Long << 4) + T_boolean;
1237: table[(T_long << 4) + T_int] = (Long2Long << 12)
1238: + (Int2Long << 4) + T_boolean;
1239: // table[(T_long<<4)+T_null] = T_undefined;
1240:
1241: // table[(T_short<<4)+T_undefined] = T_undefined;
1242: table[(T_short << 4) + T_byte] = (Short2Int << 12)
1243: + (Byte2Int << 4) + T_boolean;
1244: table[(T_short << 4) + T_long] = (Short2Long << 12)
1245: + (Long2Long << 4) + T_boolean;
1246: table[(T_short << 4) + T_short] = (Short2Int << 12)
1247: + (Short2Int << 4) + T_boolean;
1248: // table[(T_short<<4)+T_void] = T_undefined;
1249: // table[(T_short<<4)+T_String] = T_undefined;
1250: // table[(T_short<<4)+T_Object] = T_undefined;
1251: table[(T_short << 4) + T_double] = (Short2Double << 12)
1252: + (Double2Double << 4) + T_boolean;
1253: table[(T_short << 4) + T_float] = (Short2Float << 12)
1254: + (Float2Float << 4) + T_boolean;
1255: // table[(T_short<<4)+T_boolean] = T_undefined;
1256: table[(T_short << 4) + T_char] = (Short2Int << 12)
1257: + (Char2Int << 4) + T_boolean;
1258: table[(T_short << 4) + T_int] = (Short2Int << 12)
1259: + (Int2Int << 4) + T_boolean;
1260: // table[(T_short<<4)+T_null] = T_undefined;
1261:
1262: // table[(T_void<<4)+T_undefined] = T_undefined;
1263: // table[(T_void<<4)+T_byte] = T_undefined;
1264: // table[(T_void<<4)+T_long] = T_undefined;
1265: // table[(T_void<<4)+T_short] = T_undefined;
1266: // table[(T_void<<4)+T_void] = T_undefined;
1267: // table[(T_void<<4)+T_String] = T_undefined;
1268: // table[(T_void<<4)+T_Object] = T_undefined;
1269: // table[(T_void<<4)+T_double] = T_undefined;
1270: // table[(T_void<<4)+T_float] = T_undefined;
1271: // table[(T_void<<4)+T_boolean] = T_undefined;
1272: // table[(T_void<<4)+T_char] = T_undefined;
1273: // table[(T_void<<4)+T_int] = T_undefined;
1274: // table[(T_void<<4)+T_null] = T_undefined;
1275:
1276: // table[(T_String<<4)+T_undefined] = T_undefined;
1277: // table[(T_String<<4)+T_byte] = T_undefined;
1278: // table[(T_String<<4)+T_long] = T_undefined;
1279: // table[(T_String<<4)+T_short] = T_undefined;
1280: // table[(T_String<<4)+T_void] = T_undefined;
1281: // table[(T_String<<4)+T_String] = T_undefined;
1282: // table[(T_String<<4)+T_Object] = T_undefined;
1283: // table[(T_String<<4)+T_double] = T_undefined;
1284: // table[(T_String<<4)+T_float] = T_undefined;
1285: // table[(T_String<<4)+T_boolean] = T_undefined;
1286: // table[(T_String<<4)+T_char] = T_undefined;
1287: // table[(T_String<<4)+T_int] = T_undefined;
1288: // table[(T_String<<4)+T_null] = T_undefined;
1289:
1290: // table[(T_Object<<4)+T_undefined] = T_undefined;
1291: // table[(T_Object<<4)+T_byte] = T_undefined;
1292: // table[(T_Object<<4)+T_long] = T_undefined;
1293: // table[(T_Object<<4)+T_short] = T_undefined;
1294: // table[(T_Object<<4)+T_void] = T_undefined;
1295: // table[(T_Object<<4)+T_String] = T_undefined;
1296: // table[(T_Object<<4)+T_Object] = T_undefined;
1297: // table[(T_Object<<4)+T_double] = T_undefined;
1298: // table[(T_Object<<4)+T_float] = T_undefined;
1299: // table[(T_Object<<4)+T_boolean] = T_undefined;
1300: // table[(T_Object<<4)+T_char] = T_undefined;
1301: // table[(T_Object<<4)+T_int] = T_undefined;
1302: // table[(T_Object<<4)+T_null] = T_undefined;
1303:
1304: // table[(T_double<<4)+T_undefined] = T_undefined;
1305: table[(T_double << 4) + T_byte] = (Double2Double << 12)
1306: + (Byte2Double << 4) + T_boolean;
1307: table[(T_double << 4) + T_long] = (Double2Double << 12)
1308: + (Long2Double << 4) + T_boolean;
1309: table[(T_double << 4) + T_short] = (Double2Double << 12)
1310: + (Short2Double << 4) + T_boolean;
1311: // table[(T_double<<4)+T_void] = T_undefined;
1312: // table[(T_double<<4)+T_String] = T_undefined;
1313: // table[(T_double<<4)+T_Object] = T_undefined;
1314: table[(T_double << 4) + T_double] = (Double2Double << 12)
1315: + (Double2Double << 4) + T_boolean;
1316: table[(T_double << 4) + T_float] = (Double2Double << 12)
1317: + (Float2Double << 4) + T_boolean;
1318: // table[(T_double<<4)+T_boolean] = T_undefined;
1319: table[(T_double << 4) + T_char] = (Double2Double << 12)
1320: + (Char2Double << 4) + T_boolean;
1321: table[(T_double << 4) + T_int] = (Double2Double << 12)
1322: + (Int2Double << 4) + T_boolean;
1323: // table[(T_double<<4)+T_null] = T_undefined;
1324:
1325: // table[(T_float<<4)+T_undefined] = T_undefined;
1326: table[(T_float << 4) + T_byte] = (Float2Float << 12)
1327: + (Byte2Float << 4) + T_boolean;
1328: table[(T_float << 4) + T_long] = (Float2Float << 12)
1329: + (Long2Float << 4) + T_boolean;
1330: table[(T_float << 4) + T_short] = (Float2Float << 12)
1331: + (Short2Float << 4) + T_boolean;
1332: // table[(T_float<<4)+T_void] = T_undefined;
1333: // table[(T_float<<4)+T_String] = T_undefined;
1334: // table[(T_float<<4)+T_Object] = T_undefined;
1335: table[(T_float << 4) + T_double] = (Float2Double << 12)
1336: + (Double2Double << 4) + T_boolean;
1337: table[(T_float << 4) + T_float] = (Float2Float << 12)
1338: + (Float2Float << 4) + T_boolean;
1339: // table[(T_float<<4)+T_boolean] = T_undefined;
1340: table[(T_float << 4) + T_char] = (Float2Float << 12)
1341: + (Char2Float << 4) + T_boolean;
1342: table[(T_float << 4) + T_int] = (Float2Float << 12)
1343: + (Int2Float << 4) + T_boolean;
1344: // table[(T_float<<4)+T_null] = T_undefined;
1345:
1346: // table[(T_boolean<<4)+T_undefined] = T_undefined;
1347: // table[(T_boolean<<4)+T_byte] = T_undefined;
1348: // table[(T_boolean<<4)+T_long] = T_undefined;
1349: // table[(T_boolean<<4)+T_short] = T_undefined;
1350: // table[(T_boolean<<4)+T_void] = T_undefined;
1351: // table[(T_boolean<<4)+T_String] = T_undefined;
1352: // table[(T_boolean<<4)+T_Object] = T_undefined;
1353: // table[(T_boolean<<4)+T_double] = T_undefined;
1354: // table[(T_boolean<<4)+T_float] = T_undefined;
1355: // table[(T_boolean<<4)+T_boolean] = T_undefined;
1356: // table[(T_boolean<<4)+T_char] = T_undefined;
1357: // table[(T_boolean<<4)+T_int] = T_undefined;
1358: // table[(T_boolean<<4)+T_null] = T_undefined;
1359:
1360: // table[(T_char<<4)+T_undefined] = T_undefined;
1361: table[(T_char << 4) + T_byte] = (Char2Int << 12)
1362: + (Byte2Int << 4) + T_boolean;
1363: table[(T_char << 4) + T_long] = (Char2Long << 12)
1364: + (Long2Long << 4) + T_boolean;
1365: table[(T_char << 4) + T_short] = (Char2Int << 12)
1366: + (Short2Int << 4) + T_boolean;
1367: // table[(T_char<<4)+T_void] = T_undefined;
1368: // table[(T_char<<4)+T_String] = T_undefined;
1369: // table[(T_char<<4)+T_Object] = T_undefined;
1370: table[(T_char << 4) + T_double] = (Char2Double << 12)
1371: + (Double2Double << 4) + T_boolean;
1372: table[(T_char << 4) + T_float] = (Char2Float << 12)
1373: + (Float2Float << 4) + T_boolean;
1374: // table[(T_char<<4)+T_boolean] = T_undefined;
1375: table[(T_char << 4) + T_char] = (Char2Int << 12)
1376: + (Char2Int << 4) + T_boolean;
1377: table[(T_char << 4) + T_int] = (Char2Int << 12)
1378: + (Int2Int << 4) + T_boolean;
1379: // table[(T_char<<4)+T_null] = T_undefined;
1380:
1381: // table[(T_int<<4)+T_undefined] = T_undefined;
1382: table[(T_int << 4) + T_byte] = (Int2Int << 12)
1383: + (Byte2Int << 4) + T_boolean;
1384: table[(T_int << 4) + T_long] = (Int2Long << 12)
1385: + (Long2Long << 4) + T_boolean;
1386: table[(T_int << 4) + T_short] = (Int2Int << 12)
1387: + (Short2Int << 4) + T_boolean;
1388: // table[(T_int<<4)+T_void] = T_undefined;
1389: // table[(T_int<<4)+T_String] = T_undefined;
1390: // table[(T_int<<4)+T_Object] = T_undefined;
1391: table[(T_int << 4) + T_double] = (Int2Double << 12)
1392: + (Double2Double << 4) + T_boolean;
1393: table[(T_int << 4) + T_float] = (Int2Float << 12)
1394: + (Float2Float << 4) + T_boolean;
1395: // table[(T_int<<4)+T_boolean] = T_undefined;
1396: table[(T_int << 4) + T_char] = (Int2Int << 12)
1397: + (Char2Int << 4) + T_boolean;
1398: table[(T_int << 4) + T_int] = (Int2Int << 12) + (Int2Int << 4)
1399: + T_boolean;
1400: // table[(T_int<<4)+T_null] = T_undefined;
1401:
1402: // table[(T_null<<4)+T_undefined] = T_undefined;
1403: // table[(T_null<<4)+T_byte] = T_undefined;
1404: // table[(T_null<<4)+T_long] = T_undefined;
1405: // table[(T_null<<4)+T_short] = T_undefined;
1406: // table[(T_null<<4)+T_void] = T_undefined;
1407: // table[(T_null<<4)+T_String] = T_undefined;
1408: // table[(T_null<<4)+T_Object] = T_undefined;
1409: // table[(T_null<<4)+T_double] = T_undefined;
1410: // table[(T_null<<4)+T_float] = T_undefined;
1411: // table[(T_null<<4)+T_boolean] = T_undefined;
1412: // table[(T_null<<4)+T_char] = T_undefined;
1413: // table[(T_null<<4)+T_int] = T_undefined;
1414: // table[(T_null<<4)+T_null] = T_undefined;
1415:
1416: return table;
1417: }
1418:
1419: public static final int[] get_LESS_EQUAL() {
1420:
1421: //the code is an int
1422: // (cast) left Op (cast) rigth --> result
1423: // 0000 0000 0000 0000 0000
1424: // <<16 <<12 <<8 <<4
1425:
1426: // int[] table = new int[16*16];
1427: return get_LESS();
1428: }
1429:
1430: public static final int[] get_MINUS() {
1431:
1432: //the code is an int
1433: // (cast) left Op (cast) rigth --> result
1434: // 0000 0000 0000 0000 0000
1435: // <<16 <<12 <<8 <<4
1436:
1437: int[] table = (int[]) get_PLUS().clone();
1438:
1439: // customization
1440: table[(T_JavaLangString << 4) + T_byte] = T_undefined;
1441: table[(T_JavaLangString << 4) + T_long] = T_undefined;
1442: table[(T_JavaLangString << 4) + T_short] = T_undefined;
1443: table[(T_JavaLangString << 4) + T_void] = T_undefined;
1444: table[(T_JavaLangString << 4) + T_JavaLangString] = T_undefined;
1445: table[(T_JavaLangString << 4) + T_JavaLangObject] = T_undefined;
1446: table[(T_JavaLangString << 4) + T_double] = T_undefined;
1447: table[(T_JavaLangString << 4) + T_float] = T_undefined;
1448: table[(T_JavaLangString << 4) + T_boolean] = T_undefined;
1449: table[(T_JavaLangString << 4) + T_char] = T_undefined;
1450: table[(T_JavaLangString << 4) + T_int] = T_undefined;
1451: table[(T_JavaLangString << 4) + T_null] = T_undefined;
1452:
1453: table[(T_byte << 4) + T_JavaLangString] = T_undefined;
1454: table[(T_long << 4) + T_JavaLangString] = T_undefined;
1455: table[(T_short << 4) + T_JavaLangString] = T_undefined;
1456: table[(T_void << 4) + T_JavaLangString] = T_undefined;
1457: table[(T_JavaLangObject << 4) + T_JavaLangString] = T_undefined;
1458: table[(T_double << 4) + T_JavaLangString] = T_undefined;
1459: table[(T_float << 4) + T_JavaLangString] = T_undefined;
1460: table[(T_boolean << 4) + T_JavaLangString] = T_undefined;
1461: table[(T_char << 4) + T_JavaLangString] = T_undefined;
1462: table[(T_int << 4) + T_JavaLangString] = T_undefined;
1463: table[(T_null << 4) + T_JavaLangString] = T_undefined;
1464:
1465: table[(T_null << 4) + T_null] = T_undefined;
1466:
1467: return table;
1468: }
1469:
1470: public static final int[] get_MULTIPLY() {
1471:
1472: //the code is an int
1473: // (cast) left Op (cast) rigth --> result
1474: // 0000 0000 0000 0000 0000
1475: // <<16 <<12 <<8 <<4
1476:
1477: // int[] table = new int[16*16];
1478: return get_MINUS();
1479: }
1480:
1481: public static final int[] get_OR() {
1482:
1483: //the code is an int
1484: // (cast) left Op (cast) rigth --> result
1485: // 0000 0000 0000 0000 0000
1486: // <<16 <<12 <<8 <<4
1487:
1488: // int[] table = new int[16*16];
1489: return get_AND();
1490: }
1491:
1492: public static final int[] get_OR_OR() {
1493:
1494: //the code is an int
1495: // (cast) left Op (cast) rigth --> result
1496: // 0000 0000 0000 0000 0000
1497: // <<16 <<12 <<8 <<4
1498:
1499: // int[] table = new int[16*16];
1500: return get_AND_AND();
1501: }
1502:
1503: public static final int[] get_PLUS() {
1504:
1505: //the code is an int
1506: // (cast) left Op (cast) rigth --> result
1507: // 0000 0000 0000 0000 0000
1508: // <<16 <<12 <<8 <<4
1509:
1510: int[] table = new int[16 * 16];
1511:
1512: // table[(T_undefined<<4)+T_undefined] = T_undefined;
1513: // table[(T_undefined<<4)+T_byte] = T_undefined;
1514: // table[(T_undefined<<4)+T_long] = T_undefined;
1515: // table[(T_undefined<<4)+T_short] = T_undefined;
1516: // table[(T_undefined<<4)+T_void] = T_undefined;
1517: // table[(T_undefined<<4)+T_String] = T_undefined;
1518: // table[(T_undefined<<4)+T_Object] = T_undefined;
1519: // table[(T_undefined<<4)+T_double] = T_undefined;
1520: // table[(T_undefined<<4)+T_float] = T_undefined;
1521: // table[(T_undefined<<4)+T_boolean] = T_undefined;
1522: // table[(T_undefined<<4)+T_char] = T_undefined;
1523: // table[(T_undefined<<4)+T_int] = T_undefined;
1524: // table[(T_undefined<<4)+T_null] = T_undefined;
1525:
1526: // table[(T_byte<<4)+T_undefined] = T_undefined;
1527: table[(T_byte << 4) + T_byte] = (Byte2Int << 12)
1528: + (Byte2Int << 4) + T_int;
1529: table[(T_byte << 4) + T_long] = (Byte2Long << 12)
1530: + (Long2Long << 4) + T_long;
1531: table[(T_byte << 4) + T_short] = (Byte2Int << 12)
1532: + (Short2Int << 4) + T_int;
1533: // table[(T_byte<<4)+T_void] = T_undefined;
1534: table[(T_byte << 4) + T_JavaLangString] = (Byte2Byte << 12)
1535: + (String2String << 4) + T_JavaLangString;
1536: // table[(T_byte<<4)+T_Object] = T_undefined;
1537: table[(T_byte << 4) + T_double] = (Byte2Double << 12)
1538: + (Double2Double << 4) + T_double;
1539: table[(T_byte << 4) + T_float] = (Byte2Float << 12)
1540: + (Float2Float << 4) + T_float;
1541: // table[(T_byte<<4)+T_boolean] = T_undefined;
1542: table[(T_byte << 4) + T_char] = (Byte2Int << 12)
1543: + (Char2Int << 4) + T_int;
1544: table[(T_byte << 4) + T_int] = (Byte2Int << 12)
1545: + (Int2Int << 4) + T_int;
1546: // table[(T_byte<<4)+T_null] = T_undefined;
1547:
1548: // table[(T_long<<4)+T_undefined] = T_undefined;
1549: table[(T_long << 4) + T_byte] = (Long2Long << 12)
1550: + (Byte2Long << 4) + T_long;
1551: table[(T_long << 4) + T_long] = (Long2Long << 12)
1552: + (Long2Long << 4) + T_long;
1553: table[(T_long << 4) + T_short] = (Long2Long << 12)
1554: + (Short2Long << 4) + T_long;
1555: // table[(T_long<<4)+T_void] = T_undefined;
1556: table[(T_long << 4) + T_JavaLangString] = (Long2Long << 12)
1557: + (String2String << 4) + T_JavaLangString;
1558: // table[(T_long<<4)+T_Object] = T_undefined;
1559: table[(T_long << 4) + T_double] = (Long2Double << 12)
1560: + (Double2Double << 4) + T_double;
1561: table[(T_long << 4) + T_float] = (Long2Float << 12)
1562: + (Float2Float << 4) + T_float;
1563: // table[(T_long<<4)+T_boolean] = T_undefined;
1564: table[(T_long << 4) + T_char] = (Long2Long << 12)
1565: + (Char2Long << 4) + T_long;
1566: table[(T_long << 4) + T_int] = (Long2Long << 12)
1567: + (Int2Long << 4) + T_long;
1568: // table[(T_long<<4)+T_null] = T_undefined;
1569:
1570: // table[(T_short<<4)+T_undefined] = T_undefined;
1571: table[(T_short << 4) + T_byte] = (Short2Int << 12)
1572: + (Byte2Int << 4) + T_int;
1573: table[(T_short << 4) + T_long] = (Short2Long << 12)
1574: + (Long2Long << 4) + T_long;
1575: table[(T_short << 4) + T_short] = (Short2Int << 12)
1576: + (Short2Int << 4) + T_int;
1577: // table[(T_short<<4)+T_void] = T_undefined;
1578: table[(T_short << 4) + T_JavaLangString] = (Short2Short << 12)
1579: + (String2String << 4) + T_JavaLangString;
1580: // table[(T_short<<4)+T_Object] = T_undefined;
1581: table[(T_short << 4) + T_double] = (Short2Double << 12)
1582: + (Double2Double << 4) + T_double;
1583: table[(T_short << 4) + T_float] = (Short2Float << 12)
1584: + (Float2Float << 4) + T_float;
1585: // table[(T_short<<4)+T_boolean] = T_undefined;
1586: table[(T_short << 4) + T_char] = (Short2Int << 12)
1587: + (Char2Int << 4) + T_int;
1588: table[(T_short << 4) + T_int] = (Short2Int << 12)
1589: + (Int2Int << 4) + T_int;
1590: // table[(T_short<<4)+T_null] = T_undefined;
1591:
1592: // table[(T_void<<4)+T_undefined] = T_undefined;
1593: // table[(T_void<<4)+T_byte] = T_undefined;
1594: // table[(T_void<<4)+T_long] = T_undefined;
1595: // table[(T_void<<4)+T_short] = T_undefined;
1596: // table[(T_void<<4)+T_void] = T_undefined;
1597: // table[(T_void<<4)+T_String] = T_undefined;
1598: // table[(T_void<<4)+T_Object] = T_undefined;
1599: // table[(T_void<<4)+T_double] = T_undefined;
1600: // table[(T_void<<4)+T_float] = T_undefined;
1601: // table[(T_void<<4)+T_boolean] = T_undefined;
1602: // table[(T_void<<4)+T_char] = T_undefined;
1603: // table[(T_void<<4)+T_int] = T_undefined;
1604: // table[(T_void<<4)+T_null] = T_undefined;
1605:
1606: // table[(T_String<<4)+T_undefined] = T_undefined;
1607: table[(T_JavaLangString << 4) + T_byte] = (String2String << 12)
1608: + (Byte2Byte << 4) + T_JavaLangString;
1609: table[(T_JavaLangString << 4) + T_long] = (String2String << 12)
1610: + (Long2Long << 4) + T_JavaLangString;
1611: table[(T_JavaLangString << 4) + T_short] = (String2String << 12)
1612: + (Short2Short << 4) + T_JavaLangString;
1613: // table[(T_String<<4)+T_void] = T_undefined;
1614: table[(T_JavaLangString << 4) + T_JavaLangString] = (String2String << 12)
1615: + (String2String << 4) + T_JavaLangString;
1616: table[(T_JavaLangString << 4) + T_JavaLangObject] = (String2String << 12)
1617: + (Object2Object << 4) + T_JavaLangString;
1618: table[(T_JavaLangString << 4) + T_double] = (String2String << 12)
1619: + (Double2Double << 4) + T_JavaLangString;
1620: table[(T_JavaLangString << 4) + T_float] = (String2String << 12)
1621: + (Float2Float << 4) + T_JavaLangString;
1622: table[(T_JavaLangString << 4) + T_boolean] = (String2String << 12)
1623: + (Boolean2Boolean << 4) + T_JavaLangString;
1624: table[(T_JavaLangString << 4) + T_char] = (String2String << 12)
1625: + (Char2Char << 4) + T_JavaLangString;
1626: table[(T_JavaLangString << 4) + T_int] = (String2String << 12)
1627: + (Int2Int << 4) + T_JavaLangString;
1628: table[(T_JavaLangString << 4) + T_null] = (String2String << 12)
1629: + (T_null << 8) + (T_null << 4) + T_JavaLangString;
1630:
1631: // table[(T_Object<<4)+T_undefined] = T_undefined;
1632: // table[(T_Object<<4)+T_byte] = T_undefined;
1633: // table[(T_Object<<4)+T_long] = T_undefined;
1634: // table[(T_Object<<4)+T_short] = T_undefined;
1635: // table[(T_Object<<4)+T_void] = T_undefined;
1636: table[(T_JavaLangObject << 4) + T_JavaLangString] = (Object2Object << 12)
1637: + (String2String << 4) + T_JavaLangString;
1638: // table[(T_Object<<4)+T_Object] = T_undefined;
1639: // table[(T_Object<<4)+T_double] = T_undefined;
1640: // table[(T_Object<<4)+T_float] = T_undefined;
1641: // table[(T_Object<<4)+T_boolean] = T_undefined;
1642: // table[(T_Object<<4)+T_char] = T_undefined;
1643: // table[(T_Object<<4)+T_int] = T_undefined;
1644: // table[(T_Object<<4)+T_null] = T_undefined;
1645:
1646: // table[(T_double<<4)+T_undefined] = T_undefined;
1647: table[(T_double << 4) + T_byte] = (Double2Double << 12)
1648: + (Byte2Double << 4) + T_double;
1649: table[(T_double << 4) + T_long] = (Double2Double << 12)
1650: + (Long2Double << 4) + T_double;
1651: table[(T_double << 4) + T_short] = (Double2Double << 12)
1652: + (Short2Double << 4) + T_double;
1653: // table[(T_double<<4)+T_void] = T_undefined;
1654: table[(T_double << 4) + T_JavaLangString] = (Double2Double << 12)
1655: + (String2String << 4) + T_JavaLangString;
1656: // table[(T_double<<4)+T_Object] = T_undefined;
1657: table[(T_double << 4) + T_double] = (Double2Double << 12)
1658: + (Double2Double << 4) + T_double;
1659: table[(T_double << 4) + T_float] = (Double2Double << 12)
1660: + (Float2Double << 4) + T_double;
1661: // table[(T_double<<4)+T_boolean] = T_undefined;
1662: table[(T_double << 4) + T_char] = (Double2Double << 12)
1663: + (Char2Double << 4) + T_double;
1664: table[(T_double << 4) + T_int] = (Double2Double << 12)
1665: + (Int2Double << 4) + T_double;
1666: // table[(T_double<<4)+T_null] = T_undefined;
1667:
1668: // table[(T_float<<4)+T_undefined] = T_undefined;
1669: table[(T_float << 4) + T_byte] = (Float2Float << 12)
1670: + (Byte2Float << 4) + T_float;
1671: table[(T_float << 4) + T_long] = (Float2Float << 12)
1672: + (Long2Float << 4) + T_float;
1673: table[(T_float << 4) + T_short] = (Float2Float << 12)
1674: + (Short2Float << 4) + T_float;
1675: // table[(T_float<<4)+T_void] = T_undefined;
1676: table[(T_float << 4) + T_JavaLangString] = (Float2Float << 12)
1677: + (String2String << 4) + T_JavaLangString;
1678: // table[(T_float<<4)+T_Object] = T_undefined;
1679: table[(T_float << 4) + T_double] = (Float2Double << 12)
1680: + (Double2Double << 4) + T_double;
1681: table[(T_float << 4) + T_float] = (Float2Float << 12)
1682: + (Float2Float << 4) + T_float;
1683: // table[(T_float<<4)+T_boolean] = T_undefined;
1684: table[(T_float << 4) + T_char] = (Float2Float << 12)
1685: + (Char2Float << 4) + T_float;
1686: table[(T_float << 4) + T_int] = (Float2Float << 12)
1687: + (Int2Float << 4) + T_float;
1688: // table[(T_float<<4)+T_null] = T_undefined;
1689:
1690: // table[(T_boolean<<4)+T_undefined] = T_undefined;
1691: // table[(T_boolean<<4)+T_byte] = T_undefined;
1692: // table[(T_boolean<<4)+T_long] = T_undefined;
1693: // table[(T_boolean<<4)+T_short] = T_undefined;
1694: // table[(T_boolean<<4)+T_void] = T_undefined;
1695: table[(T_boolean << 4) + T_JavaLangString] = (Boolean2Boolean << 12)
1696: + (String2String << 4) + T_JavaLangString;
1697: // table[(T_boolean<<4)+T_Object] = T_undefined;
1698: // table[(T_boolean<<4)+T_double] = T_undefined;
1699: // table[(T_boolean<<4)+T_float] = T_undefined;
1700: // table[(T_boolean<<4)+T_boolean] = T_undefined;
1701: // table[(T_boolean<<4)+T_char] = T_undefined;
1702: // table[(T_boolean<<4)+T_int] = T_undefined;
1703: // table[(T_boolean<<4)+T_null] = T_undefined;
1704:
1705: // table[(T_char<<4)+T_undefined] = T_undefined;
1706: table[(T_char << 4) + T_byte] = (Char2Int << 12)
1707: + (Byte2Int << 4) + T_int;
1708: table[(T_char << 4) + T_long] = (Char2Long << 12)
1709: + (Long2Long << 4) + T_long;
1710: table[(T_char << 4) + T_short] = (Char2Int << 12)
1711: + (Short2Int << 4) + T_int;
1712: // table[(T_char<<4)+T_void] = T_undefined;
1713: table[(T_char << 4) + T_JavaLangString] = (Char2Char << 12)
1714: + (String2String << 4) + T_JavaLangString;
1715: // table[(T_char<<4)+T_Object] = T_undefined;
1716: table[(T_char << 4) + T_double] = (Char2Double << 12)
1717: + (Double2Double << 4) + T_double;
1718: table[(T_char << 4) + T_float] = (Char2Float << 12)
1719: + (Float2Float << 4) + T_float;
1720: // table[(T_char<<4)+T_boolean] = T_undefined;
1721: table[(T_char << 4) + T_char] = (Char2Int << 12)
1722: + (Char2Int << 4) + T_int;
1723: table[(T_char << 4) + T_int] = (Char2Int << 12)
1724: + (Int2Int << 4) + T_int;
1725: // table[(T_char<<4)+T_null] = T_undefined;
1726:
1727: // table[(T_int<<4)+T_undefined] = T_undefined;
1728: table[(T_int << 4) + T_byte] = (Int2Int << 12)
1729: + (Byte2Int << 4) + T_int;
1730: table[(T_int << 4) + T_long] = (Int2Long << 12)
1731: + (Long2Long << 4) + T_long;
1732: table[(T_int << 4) + T_short] = (Int2Int << 12)
1733: + (Short2Int << 4) + T_int;
1734: // table[(T_int<<4)+T_void] = T_undefined;
1735: table[(T_int << 4) + T_JavaLangString] = (Int2Int << 12)
1736: + (String2String << 4) + T_JavaLangString;
1737: // table[(T_int<<4)+T_Object] = T_undefined;
1738: table[(T_int << 4) + T_double] = (Int2Double << 12)
1739: + (Double2Double << 4) + T_double;
1740: table[(T_int << 4) + T_float] = (Int2Float << 12)
1741: + (Float2Float << 4) + T_float;
1742: // table[(T_int<<4)+T_boolean] = T_undefined;
1743: table[(T_int << 4) + T_char] = (Int2Int << 12)
1744: + (Char2Int << 4) + T_int;
1745: table[(T_int << 4) + T_int] = (Int2Int << 12) + (Int2Int << 4)
1746: + T_int;
1747: // table[(T_int<<4)+T_null] = T_undefined;
1748:
1749: // table[(T_null<<4)+T_undefined] = T_undefined;
1750: // table[(T_null<<4)+T_byte] = T_undefined;
1751: // table[(T_null<<4)+T_long] = T_undefined;
1752: // table[(T_null<<4)+T_short] = T_undefined;
1753: // table[(T_null<<4)+T_void] = T_undefined;
1754: table[(T_null << 4) + T_JavaLangString] = (T_null << 16)
1755: + (T_null << 12) + (String2String << 4)
1756: + T_JavaLangString;
1757: // table[(T_null<<4)+T_Object] = T_undefined;
1758: // table[(T_null<<4)+T_double] = T_undefined;
1759: // table[(T_null<<4)+T_float] = T_undefined;
1760: // table[(T_null<<4)+T_boolean] = T_undefined;
1761: // table[(T_null<<4)+T_char] = T_undefined;
1762: // table[(T_null<<4)+T_int] = T_undefined;
1763: // table[(T_null<<4)+T_null] = (Null2String<<12)+(Null2String<<4)+T_String;;
1764:
1765: return table;
1766: }
1767:
1768: public static final int[] get_REMAINDER() {
1769:
1770: //the code is an int
1771: // (cast) left Op (cast) rigth --> result
1772: // 0000 0000 0000 0000 0000
1773: // <<16 <<12 <<8 <<4
1774:
1775: // int[] table = new int[16*16];
1776: return get_MINUS();
1777: }
1778:
1779: public static final int[] get_RIGHT_SHIFT() {
1780:
1781: //the code is an int
1782: // (cast) left Op (cast) rigth --> result
1783: // 0000 0000 0000 0000 0000
1784: // <<16 <<12 <<8 <<4
1785:
1786: // int[] table = new int[16*16];
1787: return get_LEFT_SHIFT();
1788: }
1789:
1790: public static final int[] get_UNSIGNED_RIGHT_SHIFT() {
1791:
1792: //the code is an int
1793: // (cast) left Op (cast) rigth --> result
1794: // 0000 0000 0000 0000 0000
1795: // <<16 <<12 <<8 <<4
1796:
1797: // int[] table = new int[16*16];
1798: return get_LEFT_SHIFT();
1799: }
1800:
1801: public static final int[] get_XOR() {
1802:
1803: //the code is an int
1804: // (cast) left Op (cast) rigth --> result
1805: // 0000 0000 0000 0000 0000
1806: // <<16 <<12 <<8 <<4
1807:
1808: // int[] table = new int[16*16];
1809: return get_AND();
1810: }
1811:
1812: public String operatorToString() {
1813: switch ((bits & OperatorMASK) >> OperatorSHIFT) {
1814: case EQUAL_EQUAL:
1815: return "=="; //$NON-NLS-1$
1816: case LESS_EQUAL:
1817: return "<="; //$NON-NLS-1$
1818: case GREATER_EQUAL:
1819: return ">="; //$NON-NLS-1$
1820: case NOT_EQUAL:
1821: return "!="; //$NON-NLS-1$
1822: case LEFT_SHIFT:
1823: return "<<"; //$NON-NLS-1$
1824: case RIGHT_SHIFT:
1825: return ">>"; //$NON-NLS-1$
1826: case UNSIGNED_RIGHT_SHIFT:
1827: return ">>>"; //$NON-NLS-1$
1828: case OR_OR:
1829: return "||"; //$NON-NLS-1$
1830: case AND_AND:
1831: return "&&"; //$NON-NLS-1$
1832: case PLUS:
1833: return "+"; //$NON-NLS-1$
1834: case MINUS:
1835: return "-"; //$NON-NLS-1$
1836: case NOT:
1837: return "!"; //$NON-NLS-1$
1838: case REMAINDER:
1839: return "%"; //$NON-NLS-1$
1840: case XOR:
1841: return "^"; //$NON-NLS-1$
1842: case AND:
1843: return "&"; //$NON-NLS-1$
1844: case MULTIPLY:
1845: return "*"; //$NON-NLS-1$
1846: case OR:
1847: return "|"; //$NON-NLS-1$
1848: case TWIDDLE:
1849: return "~"; //$NON-NLS-1$
1850: case DIVIDE:
1851: return "/"; //$NON-NLS-1$
1852: case GREATER:
1853: return ">"; //$NON-NLS-1$
1854: case LESS:
1855: return "<"; //$NON-NLS-1$
1856: case QUESTIONCOLON:
1857: return "?:"; //$NON-NLS-1$
1858: case EQUAL:
1859: return "="; //$NON-NLS-1$
1860: }
1861: return "unknown operator"; //$NON-NLS-1$
1862: }
1863:
1864: public int nullStatus(FlowInfo flowInfo) {
1865: return FlowInfo.NON_NULL;
1866: }
1867:
1868: public StringBuffer printExpression(int indent, StringBuffer output) {
1869:
1870: output.append('(');
1871: return printExpressionNoParenthesis(0, output).append(')');
1872: }
1873:
1874: public abstract StringBuffer printExpressionNoParenthesis(
1875: int indent, StringBuffer output);
1876: }
|