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: *******************************************************************************/package org.eclipse.jdt.internal.compiler.impl;
0011:
0012: import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
0013: import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
0014: import org.eclipse.jdt.internal.compiler.problem.ShouldNotImplement;
0015: import org.eclipse.jdt.internal.compiler.util.Messages;
0016:
0017: public abstract class Constant implements TypeIds, OperatorIds {
0018:
0019: public static final Constant NotAConstant = DoubleConstant
0020: .fromValue(Double.NaN);
0021:
0022: public boolean booleanValue() {
0023:
0024: throw new ShouldNotImplement(Messages.bind(
0025: Messages.constant_cannotCastedInto, new String[] {
0026: typeName(), "boolean" })); //$NON-NLS-1$
0027: }
0028:
0029: public byte byteValue() {
0030:
0031: throw new ShouldNotImplement(Messages.bind(
0032: Messages.constant_cannotCastedInto, new String[] {
0033: typeName(), "byte" })); //$NON-NLS-1$
0034: }
0035:
0036: public final Constant castTo(int conversionToTargetType) {
0037: //the cast is an int of the form
0038: // (castId<<4)+typeId (in order to follow the
0039: //user written style (cast)expression ....
0040:
0041: if (this == NotAConstant)
0042: return NotAConstant;
0043: switch (conversionToTargetType) {
0044: case T_undefined:
0045: return this ;
0046: // TARGET TYPE <- FROM TYPE
0047: // case (T_undefined<<4)+T_undefined : return NotAConstant;
0048: // case (T_undefined<<4)+T_byte : return NotAConstant;
0049: // case (T_undefined<<4)+T_long : return NotAConstant;
0050: // case (T_undefined<<4)+T_short : return NotAConstant;
0051: // case (T_undefined<<4)+T_void : return NotAConstant;
0052: // case (T_undefined<<4)+T_String : return NotAConstant;
0053: // case (T_undefined<<4)+T_Object : return NotAConstant;
0054: // case (T_undefined<<4)+T_double : return NotAConstant;
0055: // case (T_undefined<<4)+T_float : return NotAConstant;
0056: // case (T_undefined<<4)+T_boolean : return NotAConstant;
0057: // case (T_undefined<<4)+T_char : return NotAConstant;
0058: // case (T_undefined<<4)+T_int : return NotAConstant;
0059:
0060: // case (T_byte<<4)+T_undefined : return NotAConstant;
0061: case (T_byte << 4) + T_byte:
0062: return this ;
0063: case (T_byte << 4) + T_long:
0064: return ByteConstant.fromValue((byte) this .longValue());
0065: case (T_byte << 4) + T_short:
0066: return ByteConstant.fromValue((byte) this .shortValue());
0067: // case (T_byte<<4)+T_void : return NotAConstant;
0068: // case (T_byte<<4)+T_String : return NotAConstant;
0069: // case (T_byte<<4)+T_Object : return NotAConstant;
0070: case (T_byte << 4) + T_double:
0071: return ByteConstant.fromValue((byte) this .doubleValue());
0072: case (T_byte << 4) + T_float:
0073: return ByteConstant.fromValue((byte) this .floatValue());
0074: // case (T_byte<<4)+T_boolean : return NotAConstant;
0075: case (T_byte << 4) + T_char:
0076: return ByteConstant.fromValue((byte) this .charValue());
0077: case (T_byte << 4) + T_int:
0078: return ByteConstant.fromValue((byte) this .intValue());
0079:
0080: // case (T_long<<4)+T_undefined : return NotAConstant;
0081: case (T_long << 4) + T_byte:
0082: return LongConstant.fromValue(this .byteValue());
0083: case (T_long << 4) + T_long:
0084: return this ;
0085: case (T_long << 4) + T_short:
0086: return LongConstant.fromValue(this .shortValue());
0087: // case (T_long<<4)+T_void : return NotAConstant;
0088: // case (T_long<<4)+T_String : return NotAConstant;
0089: // case (T_long<<4)+T_Object : return NotAConstant;
0090: case (T_long << 4) + T_double:
0091: return LongConstant.fromValue((long) this .doubleValue());
0092: case (T_long << 4) + T_float:
0093: return LongConstant.fromValue((long) this .floatValue());
0094: // case (T_long<<4)+T_boolean : return NotAConstant;
0095: case (T_long << 4) + T_char:
0096: return LongConstant.fromValue(this .charValue());
0097: case (T_long << 4) + T_int:
0098: return LongConstant.fromValue(this .intValue());
0099:
0100: // case (T_short<<4)+T_undefined : return NotAConstant;
0101: case (T_short << 4) + T_byte:
0102: return ShortConstant.fromValue(this .byteValue());
0103: case (T_short << 4) + T_long:
0104: return ShortConstant.fromValue((short) this .longValue());
0105: case (T_short << 4) + T_short:
0106: return this ;
0107: // case (T_short<<4)+T_void : return NotAConstant;
0108: // case (T_short<<4)+T_String : return NotAConstant;
0109: // case (T_short<<4)+T_Object : return NotAConstant;
0110: case (T_short << 4) + T_double:
0111: return ShortConstant.fromValue((short) this .doubleValue());
0112: case (T_short << 4) + T_float:
0113: return ShortConstant.fromValue((short) this .floatValue());
0114: // case (T_short<<4)+T_boolean : return NotAConstant;
0115: case (T_short << 4) + T_char:
0116: return ShortConstant.fromValue((short) this .charValue());
0117: case (T_short << 4) + T_int:
0118: return ShortConstant.fromValue((short) this .intValue());
0119:
0120: // case (T_void<<4)+T_undefined : return NotAConstant;
0121: // case (T_void<<4)+T_byte : return NotAConstant;
0122: // case (T_void<<4)+T_long : return NotAConstant;
0123: // case (T_void<<4)+T_short : return NotAConstant;
0124: // case (T_void<<4)+T_void : return NotAConstant;
0125: // case (T_void<<4)+T_String : return NotAConstant;
0126: // case (T_void<<4)+T_Object : return NotAConstant;
0127: // case (T_void<<4)+T_double : return NotAConstant;
0128: // case (T_void<<4)+T_float : return NotAConstant;
0129: // case (T_void<<4)+T_boolean : return NotAConstant;
0130: // case (T_void<<4)+T_char : return NotAConstant;
0131: // case (T_void<<4)+T_int : return NotAConstant;
0132:
0133: // case (T_String<<4)+T_undefined : return NotAConstant;
0134: // case (T_String<<4)+T_byte : return NotAConstant;
0135: // case (T_String<<4)+T_long : return NotAConstant;
0136: // case (T_String<<4)+T_short : return NotAConstant;
0137: // case (T_String<<4)+T_void : return NotAConstant;
0138: case (T_JavaLangString << 4) + T_JavaLangString:
0139: return this ;
0140: // case (T_String<<4)+T_Object : return NotAConstant;
0141: // case (T_String<<4)+T_double : return NotAConstant;
0142: // case (T_String<<4)+T_float : return NotAConstant;
0143: // case (T_String<<4)+T_boolean : return NotAConstant;
0144: // case (T_String<<4)+T_char : return NotAConstant;
0145: // case (T_String<<4)+T_int : return NotAConstant;
0146:
0147: // case (T_Object<<4)+T_undefined : return NotAConstant;
0148: // case (T_Object<<4)+T_byte : return NotAConstant;
0149: // case (T_Object<<4)+T_long : return NotAConstant;
0150: // case (T_Object<<4)+T_short : return NotAConstant;
0151: // case (T_Object<<4)+T_void : return NotAConstant;
0152: // case (T_Object<<4)+T_String : return NotAConstant;
0153: // case (T_Object<<4)+T_Object : return NotAConstant;
0154: // case (T_Object<<4)+T_double : return NotAConstant;
0155: // case (T_Object<<4)+T_float : return NotAConstant;
0156: // case (T_Object<<4)+T_boolean : return NotAConstant;
0157: // case (T_Object<<4)+T_char : return NotAConstant;
0158: // case (T_Object<<4)+T_int : return NotAConstant;
0159:
0160: // case (T_double<<4)+T_undefined : return NotAConstant;
0161: case (T_double << 4) + T_byte:
0162: return DoubleConstant.fromValue(this .byteValue());
0163: case (T_double << 4) + T_long:
0164: return DoubleConstant.fromValue(this .longValue());
0165: case (T_double << 4) + T_short:
0166: return DoubleConstant.fromValue(this .shortValue());
0167: // case (T_double<<4)+T_void : return NotAConstant;
0168: // case (T_double<<4)+T_String : return NotAConstant;
0169: // case (T_double<<4)+T_Object : return NotAConstant;
0170: case (T_double << 4) + T_double:
0171: return this ;
0172: case (T_double << 4) + T_float:
0173: return DoubleConstant.fromValue(this .floatValue());
0174: // case (T_double<<4)+T_boolean : return NotAConstant;
0175: case (T_double << 4) + T_char:
0176: return DoubleConstant.fromValue(this .charValue());
0177: case (T_double << 4) + T_int:
0178: return DoubleConstant.fromValue(this .intValue());
0179:
0180: // case (T_float<<4)+T_undefined : return NotAConstant;
0181: case (T_float << 4) + T_byte:
0182: return FloatConstant.fromValue(this .byteValue());
0183: case (T_float << 4) + T_long:
0184: return FloatConstant.fromValue(this .longValue());
0185: case (T_float << 4) + T_short:
0186: return FloatConstant.fromValue(this .shortValue());
0187: // case (T_float<<4)+T_void : return NotAConstant;
0188: // case (T_float<<4)+T_String : return NotAConstant;
0189: // case (T_float<<4)+T_Object : return NotAConstant;
0190: case (T_float << 4) + T_double:
0191: return FloatConstant.fromValue((float) this .doubleValue());
0192: case (T_float << 4) + T_float:
0193: return this ;
0194: // case (T_float<<4)+T_boolean : return NotAConstant;
0195: case (T_float << 4) + T_char:
0196: return FloatConstant.fromValue(this .charValue());
0197: case (T_float << 4) + T_int:
0198: return FloatConstant.fromValue(this .intValue());
0199:
0200: // case (T_boolean<<4)+T_undefined : return NotAConstant;
0201: // case (T_boolean<<4)+T_byte : return NotAConstant;
0202: // case (T_boolean<<4)+T_long : return NotAConstant;
0203: // case (T_boolean<<4)+T_short : return NotAConstant;
0204: // case (T_boolean<<4)+T_void : return NotAConstant;
0205: // case (T_boolean<<4)+T_String : return NotAConstant;
0206: // case (T_boolean<<4)+T_Object : return NotAConstant;
0207: // case (T_boolean<<4)+T_double : return NotAConstant;
0208: // case (T_boolean<<4)+T_float : return NotAConstant;
0209: case (T_boolean << 4) + T_boolean:
0210: return this ;
0211: // case (T_boolean<<4)+T_char : return NotAConstant;
0212: // case (T_boolean<<4)+T_int : return NotAConstant;
0213:
0214: // case (T_char<<4)+T_undefined : return NotAConstant;
0215: case (T_char << 4) + T_byte:
0216: return CharConstant.fromValue((char) this .byteValue());
0217: case (T_char << 4) + T_long:
0218: return CharConstant.fromValue((char) this .longValue());
0219: case (T_char << 4) + T_short:
0220: return CharConstant.fromValue((char) this .shortValue());
0221: // case (T_char<<4)+T_void : return NotAConstant;
0222: // case (T_char<<4)+T_String : return NotAConstant;
0223: // case (T_char<<4)+T_Object : return NotAConstant;
0224: case (T_char << 4) + T_double:
0225: return CharConstant.fromValue((char) this .doubleValue());
0226: case (T_char << 4) + T_float:
0227: return CharConstant.fromValue((char) this .floatValue());
0228: // case (T_char<<4)+T_boolean : return NotAConstant;
0229: case (T_char << 4) + T_char:
0230: return this ;
0231: case (T_char << 4) + T_int:
0232: return CharConstant.fromValue((char) this .intValue());
0233:
0234: // case (T_int<<4)+T_undefined : return NotAConstant;
0235: case (T_int << 4) + T_byte:
0236: return IntConstant.fromValue(this .byteValue());
0237: case (T_int << 4) + T_long:
0238: return IntConstant.fromValue((int) this .longValue());
0239: case (T_int << 4) + T_short:
0240: return IntConstant.fromValue(this .shortValue());
0241: // case (T_int<<4)+T_void : return NotAConstant;
0242: // case (T_int<<4)+T_String : return NotAConstant;
0243: // case (T_int<<4)+T_Object : return NotAConstant;
0244: case (T_int << 4) + T_double:
0245: return IntConstant.fromValue((int) this .doubleValue());
0246: case (T_int << 4) + T_float:
0247: return IntConstant.fromValue((int) this .floatValue());
0248: // case (T_int<<4)+T_boolean : return NotAConstant;
0249: case (T_int << 4) + T_char:
0250: return IntConstant.fromValue(this .charValue());
0251: case (T_int << 4) + T_int:
0252: return this ;
0253:
0254: }
0255:
0256: return NotAConstant;
0257: }
0258:
0259: public char charValue() {
0260:
0261: throw new ShouldNotImplement(Messages.bind(
0262: Messages.constant_cannotCastedInto, new String[] {
0263: typeName(), "char" })); //$NON-NLS-1$
0264: }
0265:
0266: public static final Constant computeConstantOperation(Constant cst,
0267: int id, int operator) {
0268:
0269: switch (operator) {
0270: case NOT:
0271: return BooleanConstant.fromValue(!cst.booleanValue());
0272: case PLUS:
0273: return computeConstantOperationPLUS(IntConstant
0274: .fromValue(0), T_int, cst, id);
0275: case MINUS: //the two special -9223372036854775808L and -2147483648 are inlined at parseTime
0276: switch (id) {
0277: case T_float:
0278: float f;
0279: if ((f = cst.floatValue()) == 0.0f) { //positive and negative 0....
0280: if (Float.floatToIntBits(f) == 0)
0281: return FloatConstant.fromValue(-0.0f);
0282: else
0283: return FloatConstant.fromValue(0.0f);
0284: }
0285: break; //default case
0286: case T_double:
0287: double d;
0288: if ((d = cst.doubleValue()) == 0.0d) { //positive and negative 0....
0289: if (Double.doubleToLongBits(d) == 0)
0290: return DoubleConstant.fromValue(-0.0d);
0291: else
0292: return DoubleConstant.fromValue(0.0d);
0293: }
0294: break; //default case
0295: }
0296: return computeConstantOperationMINUS(IntConstant
0297: .fromValue(0), T_int, cst, id);
0298: case TWIDDLE:
0299: switch (id) {
0300: case T_char:
0301: return IntConstant.fromValue(~cst.charValue());
0302: case T_byte:
0303: return IntConstant.fromValue(~cst.byteValue());
0304: case T_short:
0305: return IntConstant.fromValue(~cst.shortValue());
0306: case T_int:
0307: return IntConstant.fromValue(~cst.intValue());
0308: case T_long:
0309: return LongConstant.fromValue(~cst.longValue());
0310: default:
0311: return NotAConstant;
0312: }
0313: default:
0314: return NotAConstant;
0315: }
0316: }
0317:
0318: public static final Constant computeConstantOperation(
0319: Constant left, int leftId, int operator, Constant right,
0320: int rightId) {
0321:
0322: switch (operator) {
0323: case AND:
0324: return computeConstantOperationAND(left, leftId, right,
0325: rightId);
0326: case AND_AND:
0327: return computeConstantOperationAND_AND(left, leftId, right,
0328: rightId);
0329: case DIVIDE:
0330: return computeConstantOperationDIVIDE(left, leftId, right,
0331: rightId);
0332: case GREATER:
0333: return computeConstantOperationGREATER(left, leftId, right,
0334: rightId);
0335: case GREATER_EQUAL:
0336: return computeConstantOperationGREATER_EQUAL(left, leftId,
0337: right, rightId);
0338: case LEFT_SHIFT:
0339: return computeConstantOperationLEFT_SHIFT(left, leftId,
0340: right, rightId);
0341: case LESS:
0342: return computeConstantOperationLESS(left, leftId, right,
0343: rightId);
0344: case LESS_EQUAL:
0345: return computeConstantOperationLESS_EQUAL(left, leftId,
0346: right, rightId);
0347: case MINUS:
0348: return computeConstantOperationMINUS(left, leftId, right,
0349: rightId);
0350: case MULTIPLY:
0351: return computeConstantOperationMULTIPLY(left, leftId,
0352: right, rightId);
0353: case OR:
0354: return computeConstantOperationOR(left, leftId, right,
0355: rightId);
0356: case OR_OR:
0357: return computeConstantOperationOR_OR(left, leftId, right,
0358: rightId);
0359: case PLUS:
0360: return computeConstantOperationPLUS(left, leftId, right,
0361: rightId);
0362: case REMAINDER:
0363: return computeConstantOperationREMAINDER(left, leftId,
0364: right, rightId);
0365: case RIGHT_SHIFT:
0366: return computeConstantOperationRIGHT_SHIFT(left, leftId,
0367: right, rightId);
0368: case UNSIGNED_RIGHT_SHIFT:
0369: return computeConstantOperationUNSIGNED_RIGHT_SHIFT(left,
0370: leftId, right, rightId);
0371: case XOR:
0372: return computeConstantOperationXOR(left, leftId, right,
0373: rightId);
0374:
0375: default:
0376: return NotAConstant;
0377: }
0378: }
0379:
0380: public static final Constant computeConstantOperationAND(
0381: Constant left, int leftId, Constant right, int rightId) {
0382:
0383: switch (leftId) {
0384: case T_boolean:
0385: return BooleanConstant.fromValue(left.booleanValue()
0386: & right.booleanValue());
0387: case T_char:
0388: switch (rightId) {
0389: case T_char:
0390: return IntConstant.fromValue(left.charValue()
0391: & right.charValue());
0392: case T_byte:
0393: return IntConstant.fromValue(left.charValue()
0394: & right.byteValue());
0395: case T_short:
0396: return IntConstant.fromValue(left.charValue()
0397: & right.shortValue());
0398: case T_int:
0399: return IntConstant.fromValue(left.charValue()
0400: & right.intValue());
0401: case T_long:
0402: return LongConstant.fromValue(left.charValue()
0403: & right.longValue());
0404: }
0405: break;
0406: case T_byte:
0407: switch (rightId) {
0408: case T_char:
0409: return IntConstant.fromValue(left.byteValue()
0410: & right.charValue());
0411: case T_byte:
0412: return IntConstant.fromValue(left.byteValue()
0413: & right.byteValue());
0414: case T_short:
0415: return IntConstant.fromValue(left.byteValue()
0416: & right.shortValue());
0417: case T_int:
0418: return IntConstant.fromValue(left.byteValue()
0419: & right.intValue());
0420: case T_long:
0421: return LongConstant.fromValue(left.byteValue()
0422: & right.longValue());
0423: }
0424: break;
0425: case T_short:
0426: switch (rightId) {
0427: case T_char:
0428: return IntConstant.fromValue(left.shortValue()
0429: & right.charValue());
0430: case T_byte:
0431: return IntConstant.fromValue(left.shortValue()
0432: & right.byteValue());
0433: case T_short:
0434: return IntConstant.fromValue(left.shortValue()
0435: & right.shortValue());
0436: case T_int:
0437: return IntConstant.fromValue(left.shortValue()
0438: & right.intValue());
0439: case T_long:
0440: return LongConstant.fromValue(left.shortValue()
0441: & right.longValue());
0442: }
0443: break;
0444: case T_int:
0445: switch (rightId) {
0446: case T_char:
0447: return IntConstant.fromValue(left.intValue()
0448: & right.charValue());
0449: case T_byte:
0450: return IntConstant.fromValue(left.intValue()
0451: & right.byteValue());
0452: case T_short:
0453: return IntConstant.fromValue(left.intValue()
0454: & right.shortValue());
0455: case T_int:
0456: return IntConstant.fromValue(left.intValue()
0457: & right.intValue());
0458: case T_long:
0459: return LongConstant.fromValue(left.intValue()
0460: & right.longValue());
0461: }
0462: break;
0463: case T_long:
0464: switch (rightId) {
0465: case T_char:
0466: return LongConstant.fromValue(left.longValue()
0467: & right.charValue());
0468: case T_byte:
0469: return LongConstant.fromValue(left.longValue()
0470: & right.byteValue());
0471: case T_short:
0472: return LongConstant.fromValue(left.longValue()
0473: & right.shortValue());
0474: case T_int:
0475: return LongConstant.fromValue(left.longValue()
0476: & right.intValue());
0477: case T_long:
0478: return LongConstant.fromValue(left.longValue()
0479: & right.longValue());
0480: }
0481: }
0482:
0483: return NotAConstant;
0484: }
0485:
0486: public static final Constant computeConstantOperationAND_AND(
0487: Constant left, int leftId, Constant right, int rightId) {
0488:
0489: return BooleanConstant.fromValue(left.booleanValue()
0490: && right.booleanValue());
0491: }
0492:
0493: public static final Constant computeConstantOperationDIVIDE(
0494: Constant left, int leftId, Constant right, int rightId) {
0495: // division by zero must be handled outside this method (error reporting)
0496:
0497: switch (leftId) {
0498: case T_char:
0499: switch (rightId) {
0500: case T_char:
0501: return IntConstant.fromValue(left.charValue()
0502: / right.charValue());
0503: case T_float:
0504: return FloatConstant.fromValue(left.charValue()
0505: / right.floatValue());
0506: case T_double:
0507: return DoubleConstant.fromValue(left.charValue()
0508: / right.doubleValue());
0509: case T_byte:
0510: return IntConstant.fromValue(left.charValue()
0511: / right.byteValue());
0512: case T_short:
0513: return IntConstant.fromValue(left.charValue()
0514: / right.shortValue());
0515: case T_int:
0516: return IntConstant.fromValue(left.charValue()
0517: / right.intValue());
0518: case T_long:
0519: return LongConstant.fromValue(left.charValue()
0520: / right.longValue());
0521: }
0522: break;
0523: case T_float:
0524: switch (rightId) {
0525: case T_char:
0526: return FloatConstant.fromValue(left.floatValue()
0527: / right.charValue());
0528: case T_float:
0529: return FloatConstant.fromValue(left.floatValue()
0530: / right.floatValue());
0531: case T_double:
0532: return DoubleConstant.fromValue(left.floatValue()
0533: / right.doubleValue());
0534: case T_byte:
0535: return FloatConstant.fromValue(left.floatValue()
0536: / right.byteValue());
0537: case T_short:
0538: return FloatConstant.fromValue(left.floatValue()
0539: / right.shortValue());
0540: case T_int:
0541: return FloatConstant.fromValue(left.floatValue()
0542: / right.intValue());
0543: case T_long:
0544: return FloatConstant.fromValue(left.floatValue()
0545: / right.longValue());
0546: }
0547: break;
0548: case T_double:
0549: switch (rightId) {
0550: case T_char:
0551: return DoubleConstant.fromValue(left.doubleValue()
0552: / right.charValue());
0553: case T_float:
0554: return DoubleConstant.fromValue(left.doubleValue()
0555: / right.floatValue());
0556: case T_double:
0557: return DoubleConstant.fromValue(left.doubleValue()
0558: / right.doubleValue());
0559: case T_byte:
0560: return DoubleConstant.fromValue(left.doubleValue()
0561: / right.byteValue());
0562: case T_short:
0563: return DoubleConstant.fromValue(left.doubleValue()
0564: / right.shortValue());
0565: case T_int:
0566: return DoubleConstant.fromValue(left.doubleValue()
0567: / right.intValue());
0568: case T_long:
0569: return DoubleConstant.fromValue(left.doubleValue()
0570: / right.longValue());
0571: }
0572: break;
0573: case T_byte:
0574: switch (rightId) {
0575: case T_char:
0576: return IntConstant.fromValue(left.byteValue()
0577: / right.charValue());
0578: case T_float:
0579: return FloatConstant.fromValue(left.byteValue()
0580: / right.floatValue());
0581: case T_double:
0582: return DoubleConstant.fromValue(left.byteValue()
0583: / right.doubleValue());
0584: case T_byte:
0585: return IntConstant.fromValue(left.byteValue()
0586: / right.byteValue());
0587: case T_short:
0588: return IntConstant.fromValue(left.byteValue()
0589: / right.shortValue());
0590: case T_int:
0591: return IntConstant.fromValue(left.byteValue()
0592: / right.intValue());
0593: case T_long:
0594: return LongConstant.fromValue(left.byteValue()
0595: / right.longValue());
0596: }
0597: break;
0598: case T_short:
0599: switch (rightId) {
0600: case T_char:
0601: return IntConstant.fromValue(left.shortValue()
0602: / right.charValue());
0603: case T_float:
0604: return FloatConstant.fromValue(left.shortValue()
0605: / right.floatValue());
0606: case T_double:
0607: return DoubleConstant.fromValue(left.shortValue()
0608: / right.doubleValue());
0609: case T_byte:
0610: return IntConstant.fromValue(left.shortValue()
0611: / right.byteValue());
0612: case T_short:
0613: return IntConstant.fromValue(left.shortValue()
0614: / right.shortValue());
0615: case T_int:
0616: return IntConstant.fromValue(left.shortValue()
0617: / right.intValue());
0618: case T_long:
0619: return LongConstant.fromValue(left.shortValue()
0620: / right.longValue());
0621: }
0622: break;
0623: case T_int:
0624: switch (rightId) {
0625: case T_char:
0626: return IntConstant.fromValue(left.intValue()
0627: / right.charValue());
0628: case T_float:
0629: return FloatConstant.fromValue(left.intValue()
0630: / right.floatValue());
0631: case T_double:
0632: return DoubleConstant.fromValue(left.intValue()
0633: / right.doubleValue());
0634: case T_byte:
0635: return IntConstant.fromValue(left.intValue()
0636: / right.byteValue());
0637: case T_short:
0638: return IntConstant.fromValue(left.intValue()
0639: / right.shortValue());
0640: case T_int:
0641: return IntConstant.fromValue(left.intValue()
0642: / right.intValue());
0643: case T_long:
0644: return LongConstant.fromValue(left.intValue()
0645: / right.longValue());
0646: }
0647: break;
0648: case T_long:
0649: switch (rightId) {
0650: case T_char:
0651: return LongConstant.fromValue(left.longValue()
0652: / right.charValue());
0653: case T_float:
0654: return FloatConstant.fromValue(left.longValue()
0655: / right.floatValue());
0656: case T_double:
0657: return DoubleConstant.fromValue(left.longValue()
0658: / right.doubleValue());
0659: case T_byte:
0660: return LongConstant.fromValue(left.longValue()
0661: / right.byteValue());
0662: case T_short:
0663: return LongConstant.fromValue(left.longValue()
0664: / right.shortValue());
0665: case T_int:
0666: return LongConstant.fromValue(left.longValue()
0667: / right.intValue());
0668: case T_long:
0669: return LongConstant.fromValue(left.longValue()
0670: / right.longValue());
0671: }
0672:
0673: }
0674:
0675: return NotAConstant;
0676: }
0677:
0678: public static final Constant computeConstantOperationEQUAL_EQUAL(
0679: Constant left, int leftId, Constant right, int rightId) {
0680:
0681: switch (leftId) {
0682: case T_boolean:
0683: if (rightId == T_boolean) {
0684: return BooleanConstant
0685: .fromValue(left.booleanValue() == right
0686: .booleanValue());
0687: }
0688: break;
0689: case T_char:
0690: switch (rightId) {
0691: case T_char:
0692: return BooleanConstant
0693: .fromValue(left.charValue() == right
0694: .charValue());
0695: case T_float:
0696: return BooleanConstant
0697: .fromValue(left.charValue() == right
0698: .floatValue());
0699: case T_double:
0700: return BooleanConstant
0701: .fromValue(left.charValue() == right
0702: .doubleValue());
0703: case T_byte:
0704: return BooleanConstant
0705: .fromValue(left.charValue() == right
0706: .byteValue());
0707: case T_short:
0708: return BooleanConstant
0709: .fromValue(left.charValue() == right
0710: .shortValue());
0711: case T_int:
0712: return BooleanConstant
0713: .fromValue(left.charValue() == right.intValue());
0714: case T_long:
0715: return BooleanConstant
0716: .fromValue(left.charValue() == right
0717: .longValue());
0718: }
0719: break;
0720: case T_float:
0721: switch (rightId) {
0722: case T_char:
0723: return BooleanConstant
0724: .fromValue(left.floatValue() == right
0725: .charValue());
0726: case T_float:
0727: return BooleanConstant
0728: .fromValue(left.floatValue() == right
0729: .floatValue());
0730: case T_double:
0731: return BooleanConstant
0732: .fromValue(left.floatValue() == right
0733: .doubleValue());
0734: case T_byte:
0735: return BooleanConstant
0736: .fromValue(left.floatValue() == right
0737: .byteValue());
0738: case T_short:
0739: return BooleanConstant
0740: .fromValue(left.floatValue() == right
0741: .shortValue());
0742: case T_int:
0743: return BooleanConstant
0744: .fromValue(left.floatValue() == right
0745: .intValue());
0746: case T_long:
0747: return BooleanConstant
0748: .fromValue(left.floatValue() == right
0749: .longValue());
0750: }
0751: break;
0752: case T_double:
0753: switch (rightId) {
0754: case T_char:
0755: return BooleanConstant
0756: .fromValue(left.doubleValue() == right
0757: .charValue());
0758: case T_float:
0759: return BooleanConstant
0760: .fromValue(left.doubleValue() == right
0761: .floatValue());
0762: case T_double:
0763: return BooleanConstant
0764: .fromValue(left.doubleValue() == right
0765: .doubleValue());
0766: case T_byte:
0767: return BooleanConstant
0768: .fromValue(left.doubleValue() == right
0769: .byteValue());
0770: case T_short:
0771: return BooleanConstant
0772: .fromValue(left.doubleValue() == right
0773: .shortValue());
0774: case T_int:
0775: return BooleanConstant
0776: .fromValue(left.doubleValue() == right
0777: .intValue());
0778: case T_long:
0779: return BooleanConstant
0780: .fromValue(left.doubleValue() == right
0781: .longValue());
0782: }
0783: break;
0784: case T_byte:
0785: switch (rightId) {
0786: case T_char:
0787: return BooleanConstant
0788: .fromValue(left.byteValue() == right
0789: .charValue());
0790: case T_float:
0791: return BooleanConstant
0792: .fromValue(left.byteValue() == right
0793: .floatValue());
0794: case T_double:
0795: return BooleanConstant
0796: .fromValue(left.byteValue() == right
0797: .doubleValue());
0798: case T_byte:
0799: return BooleanConstant
0800: .fromValue(left.byteValue() == right
0801: .byteValue());
0802: case T_short:
0803: return BooleanConstant
0804: .fromValue(left.byteValue() == right
0805: .shortValue());
0806: case T_int:
0807: return BooleanConstant
0808: .fromValue(left.byteValue() == right.intValue());
0809: case T_long:
0810: return BooleanConstant
0811: .fromValue(left.byteValue() == right
0812: .longValue());
0813: }
0814: break;
0815: case T_short:
0816: switch (rightId) {
0817: case T_char:
0818: return BooleanConstant
0819: .fromValue(left.shortValue() == right
0820: .charValue());
0821: case T_float:
0822: return BooleanConstant
0823: .fromValue(left.shortValue() == right
0824: .floatValue());
0825: case T_double:
0826: return BooleanConstant
0827: .fromValue(left.shortValue() == right
0828: .doubleValue());
0829: case T_byte:
0830: return BooleanConstant
0831: .fromValue(left.shortValue() == right
0832: .byteValue());
0833: case T_short:
0834: return BooleanConstant
0835: .fromValue(left.shortValue() == right
0836: .shortValue());
0837: case T_int:
0838: return BooleanConstant
0839: .fromValue(left.shortValue() == right
0840: .intValue());
0841: case T_long:
0842: return BooleanConstant
0843: .fromValue(left.shortValue() == right
0844: .longValue());
0845: }
0846: break;
0847: case T_int:
0848: switch (rightId) {
0849: case T_char:
0850: return BooleanConstant
0851: .fromValue(left.intValue() == right.charValue());
0852: case T_float:
0853: return BooleanConstant
0854: .fromValue(left.intValue() == right
0855: .floatValue());
0856: case T_double:
0857: return BooleanConstant
0858: .fromValue(left.intValue() == right
0859: .doubleValue());
0860: case T_byte:
0861: return BooleanConstant
0862: .fromValue(left.intValue() == right.byteValue());
0863: case T_short:
0864: return BooleanConstant
0865: .fromValue(left.intValue() == right
0866: .shortValue());
0867: case T_int:
0868: return BooleanConstant
0869: .fromValue(left.intValue() == right.intValue());
0870: case T_long:
0871: return BooleanConstant
0872: .fromValue(left.intValue() == right.longValue());
0873: }
0874: break;
0875: case T_long:
0876: switch (rightId) {
0877: case T_char:
0878: return BooleanConstant
0879: .fromValue(left.longValue() == right
0880: .charValue());
0881: case T_float:
0882: return BooleanConstant
0883: .fromValue(left.longValue() == right
0884: .floatValue());
0885: case T_double:
0886: return BooleanConstant
0887: .fromValue(left.longValue() == right
0888: .doubleValue());
0889: case T_byte:
0890: return BooleanConstant
0891: .fromValue(left.longValue() == right
0892: .byteValue());
0893: case T_short:
0894: return BooleanConstant
0895: .fromValue(left.longValue() == right
0896: .shortValue());
0897: case T_int:
0898: return BooleanConstant
0899: .fromValue(left.longValue() == right.intValue());
0900: case T_long:
0901: return BooleanConstant
0902: .fromValue(left.longValue() == right
0903: .longValue());
0904: }
0905: break;
0906: case T_JavaLangString:
0907: if (rightId == T_JavaLangString) {
0908: //String are interned in th compiler==>thus if two string constant
0909: //get to be compared, it is an equal on the vale which is done
0910: return BooleanConstant
0911: .fromValue(((StringConstant) left)
0912: .hasSameValue(right));
0913: }
0914: break;
0915: case T_null:
0916: if (rightId == T_JavaLangString) {
0917: return BooleanConstant.fromValue(false);
0918: } else {
0919: if (rightId == T_null) {
0920: return BooleanConstant.fromValue(true);
0921: }
0922: }
0923: }
0924:
0925: return BooleanConstant.fromValue(false);
0926: }
0927:
0928: public static final Constant computeConstantOperationGREATER(
0929: Constant left, int leftId, Constant right, int rightId) {
0930:
0931: switch (leftId) {
0932: case T_char:
0933: switch (rightId) {
0934: case T_char:
0935: return BooleanConstant
0936: .fromValue(left.charValue() > right.charValue());
0937: case T_float:
0938: return BooleanConstant
0939: .fromValue(left.charValue() > right
0940: .floatValue());
0941: case T_double:
0942: return BooleanConstant
0943: .fromValue(left.charValue() > right
0944: .doubleValue());
0945: case T_byte:
0946: return BooleanConstant
0947: .fromValue(left.charValue() > right.byteValue());
0948: case T_short:
0949: return BooleanConstant
0950: .fromValue(left.charValue() > right
0951: .shortValue());
0952: case T_int:
0953: return BooleanConstant
0954: .fromValue(left.charValue() > right.intValue());
0955: case T_long:
0956: return BooleanConstant
0957: .fromValue(left.charValue() > right.longValue());
0958: }
0959: break;
0960: case T_float:
0961: switch (rightId) {
0962: case T_char:
0963: return BooleanConstant
0964: .fromValue(left.floatValue() > right
0965: .charValue());
0966: case T_float:
0967: return BooleanConstant
0968: .fromValue(left.floatValue() > right
0969: .floatValue());
0970: case T_double:
0971: return BooleanConstant
0972: .fromValue(left.floatValue() > right
0973: .doubleValue());
0974: case T_byte:
0975: return BooleanConstant
0976: .fromValue(left.floatValue() > right
0977: .byteValue());
0978: case T_short:
0979: return BooleanConstant
0980: .fromValue(left.floatValue() > right
0981: .shortValue());
0982: case T_int:
0983: return BooleanConstant
0984: .fromValue(left.floatValue() > right.intValue());
0985: case T_long:
0986: return BooleanConstant
0987: .fromValue(left.floatValue() > right
0988: .longValue());
0989: }
0990: break;
0991: case T_double:
0992: switch (rightId) {
0993: case T_char:
0994: return BooleanConstant
0995: .fromValue(left.doubleValue() > right
0996: .charValue());
0997: case T_float:
0998: return BooleanConstant
0999: .fromValue(left.doubleValue() > right
1000: .floatValue());
1001: case T_double:
1002: return BooleanConstant
1003: .fromValue(left.doubleValue() > right
1004: .doubleValue());
1005: case T_byte:
1006: return BooleanConstant
1007: .fromValue(left.doubleValue() > right
1008: .byteValue());
1009: case T_short:
1010: return BooleanConstant
1011: .fromValue(left.doubleValue() > right
1012: .shortValue());
1013: case T_int:
1014: return BooleanConstant
1015: .fromValue(left.doubleValue() > right
1016: .intValue());
1017: case T_long:
1018: return BooleanConstant
1019: .fromValue(left.doubleValue() > right
1020: .longValue());
1021: }
1022: break;
1023: case T_byte:
1024: switch (rightId) {
1025: case T_char:
1026: return BooleanConstant
1027: .fromValue(left.byteValue() > right.charValue());
1028: case T_float:
1029: return BooleanConstant
1030: .fromValue(left.byteValue() > right
1031: .floatValue());
1032: case T_double:
1033: return BooleanConstant
1034: .fromValue(left.byteValue() > right
1035: .doubleValue());
1036: case T_byte:
1037: return BooleanConstant
1038: .fromValue(left.byteValue() > right.byteValue());
1039: case T_short:
1040: return BooleanConstant
1041: .fromValue(left.byteValue() > right
1042: .shortValue());
1043: case T_int:
1044: return BooleanConstant
1045: .fromValue(left.byteValue() > right.intValue());
1046: case T_long:
1047: return BooleanConstant
1048: .fromValue(left.byteValue() > right.longValue());
1049: }
1050: break;
1051: case T_short:
1052: switch (rightId) {
1053: case T_char:
1054: return BooleanConstant
1055: .fromValue(left.shortValue() > right
1056: .charValue());
1057: case T_float:
1058: return BooleanConstant
1059: .fromValue(left.shortValue() > right
1060: .floatValue());
1061: case T_double:
1062: return BooleanConstant
1063: .fromValue(left.shortValue() > right
1064: .doubleValue());
1065: case T_byte:
1066: return BooleanConstant
1067: .fromValue(left.shortValue() > right
1068: .byteValue());
1069: case T_short:
1070: return BooleanConstant
1071: .fromValue(left.shortValue() > right
1072: .shortValue());
1073: case T_int:
1074: return BooleanConstant
1075: .fromValue(left.shortValue() > right.intValue());
1076: case T_long:
1077: return BooleanConstant
1078: .fromValue(left.shortValue() > right
1079: .longValue());
1080: }
1081: break;
1082: case T_int:
1083: switch (rightId) {
1084: case T_char:
1085: return BooleanConstant
1086: .fromValue(left.intValue() > right.charValue());
1087: case T_float:
1088: return BooleanConstant
1089: .fromValue(left.intValue() > right.floatValue());
1090: case T_double:
1091: return BooleanConstant
1092: .fromValue(left.intValue() > right
1093: .doubleValue());
1094: case T_byte:
1095: return BooleanConstant
1096: .fromValue(left.intValue() > right.byteValue());
1097: case T_short:
1098: return BooleanConstant
1099: .fromValue(left.intValue() > right.shortValue());
1100: case T_int:
1101: return BooleanConstant
1102: .fromValue(left.intValue() > right.intValue());
1103: case T_long:
1104: return BooleanConstant
1105: .fromValue(left.intValue() > right.longValue());
1106: }
1107: break;
1108: case T_long:
1109: switch (rightId) {
1110: case T_char:
1111: return BooleanConstant
1112: .fromValue(left.longValue() > right.charValue());
1113: case T_float:
1114: return BooleanConstant
1115: .fromValue(left.longValue() > right
1116: .floatValue());
1117: case T_double:
1118: return BooleanConstant
1119: .fromValue(left.longValue() > right
1120: .doubleValue());
1121: case T_byte:
1122: return BooleanConstant
1123: .fromValue(left.longValue() > right.byteValue());
1124: case T_short:
1125: return BooleanConstant
1126: .fromValue(left.longValue() > right
1127: .shortValue());
1128: case T_int:
1129: return BooleanConstant
1130: .fromValue(left.longValue() > right.intValue());
1131: case T_long:
1132: return BooleanConstant
1133: .fromValue(left.longValue() > right.longValue());
1134: }
1135:
1136: }
1137:
1138: return NotAConstant;
1139: }
1140:
1141: public static final Constant computeConstantOperationGREATER_EQUAL(
1142: Constant left, int leftId, Constant right, int rightId) {
1143:
1144: switch (leftId) {
1145: case T_char:
1146: switch (rightId) {
1147: case T_char:
1148: return BooleanConstant
1149: .fromValue(left.charValue() >= right
1150: .charValue());
1151: case T_float:
1152: return BooleanConstant
1153: .fromValue(left.charValue() >= right
1154: .floatValue());
1155: case T_double:
1156: return BooleanConstant
1157: .fromValue(left.charValue() >= right
1158: .doubleValue());
1159: case T_byte:
1160: return BooleanConstant
1161: .fromValue(left.charValue() >= right
1162: .byteValue());
1163: case T_short:
1164: return BooleanConstant
1165: .fromValue(left.charValue() >= right
1166: .shortValue());
1167: case T_int:
1168: return BooleanConstant
1169: .fromValue(left.charValue() >= right.intValue());
1170: case T_long:
1171: return BooleanConstant
1172: .fromValue(left.charValue() >= right
1173: .longValue());
1174: }
1175: break;
1176: case T_float:
1177: switch (rightId) {
1178: case T_char:
1179: return BooleanConstant
1180: .fromValue(left.floatValue() >= right
1181: .charValue());
1182: case T_float:
1183: return BooleanConstant
1184: .fromValue(left.floatValue() >= right
1185: .floatValue());
1186: case T_double:
1187: return BooleanConstant
1188: .fromValue(left.floatValue() >= right
1189: .doubleValue());
1190: case T_byte:
1191: return BooleanConstant
1192: .fromValue(left.floatValue() >= right
1193: .byteValue());
1194: case T_short:
1195: return BooleanConstant
1196: .fromValue(left.floatValue() >= right
1197: .shortValue());
1198: case T_int:
1199: return BooleanConstant
1200: .fromValue(left.floatValue() >= right
1201: .intValue());
1202: case T_long:
1203: return BooleanConstant
1204: .fromValue(left.floatValue() >= right
1205: .longValue());
1206: }
1207: break;
1208: case T_double:
1209: switch (rightId) {
1210: case T_char:
1211: return BooleanConstant
1212: .fromValue(left.doubleValue() >= right
1213: .charValue());
1214: case T_float:
1215: return BooleanConstant
1216: .fromValue(left.doubleValue() >= right
1217: .floatValue());
1218: case T_double:
1219: return BooleanConstant
1220: .fromValue(left.doubleValue() >= right
1221: .doubleValue());
1222: case T_byte:
1223: return BooleanConstant
1224: .fromValue(left.doubleValue() >= right
1225: .byteValue());
1226: case T_short:
1227: return BooleanConstant
1228: .fromValue(left.doubleValue() >= right
1229: .shortValue());
1230: case T_int:
1231: return BooleanConstant
1232: .fromValue(left.doubleValue() >= right
1233: .intValue());
1234: case T_long:
1235: return BooleanConstant
1236: .fromValue(left.doubleValue() >= right
1237: .longValue());
1238: }
1239: break;
1240: case T_byte:
1241: switch (rightId) {
1242: case T_char:
1243: return BooleanConstant
1244: .fromValue(left.byteValue() >= right
1245: .charValue());
1246: case T_float:
1247: return BooleanConstant
1248: .fromValue(left.byteValue() >= right
1249: .floatValue());
1250: case T_double:
1251: return BooleanConstant
1252: .fromValue(left.byteValue() >= right
1253: .doubleValue());
1254: case T_byte:
1255: return BooleanConstant
1256: .fromValue(left.byteValue() >= right
1257: .byteValue());
1258: case T_short:
1259: return BooleanConstant
1260: .fromValue(left.byteValue() >= right
1261: .shortValue());
1262: case T_int:
1263: return BooleanConstant
1264: .fromValue(left.byteValue() >= right.intValue());
1265: case T_long:
1266: return BooleanConstant
1267: .fromValue(left.byteValue() >= right
1268: .longValue());
1269: }
1270: break;
1271: case T_short:
1272: switch (rightId) {
1273: case T_char:
1274: return BooleanConstant
1275: .fromValue(left.shortValue() >= right
1276: .charValue());
1277: case T_float:
1278: return BooleanConstant
1279: .fromValue(left.shortValue() >= right
1280: .floatValue());
1281: case T_double:
1282: return BooleanConstant
1283: .fromValue(left.shortValue() >= right
1284: .doubleValue());
1285: case T_byte:
1286: return BooleanConstant
1287: .fromValue(left.shortValue() >= right
1288: .byteValue());
1289: case T_short:
1290: return BooleanConstant
1291: .fromValue(left.shortValue() >= right
1292: .shortValue());
1293: case T_int:
1294: return BooleanConstant
1295: .fromValue(left.shortValue() >= right
1296: .intValue());
1297: case T_long:
1298: return BooleanConstant
1299: .fromValue(left.shortValue() >= right
1300: .longValue());
1301: }
1302: break;
1303: case T_int:
1304: switch (rightId) {
1305: case T_char:
1306: return BooleanConstant
1307: .fromValue(left.intValue() >= right.charValue());
1308: case T_float:
1309: return BooleanConstant
1310: .fromValue(left.intValue() >= right
1311: .floatValue());
1312: case T_double:
1313: return BooleanConstant
1314: .fromValue(left.intValue() >= right
1315: .doubleValue());
1316: case T_byte:
1317: return BooleanConstant
1318: .fromValue(left.intValue() >= right.byteValue());
1319: case T_short:
1320: return BooleanConstant
1321: .fromValue(left.intValue() >= right
1322: .shortValue());
1323: case T_int:
1324: return BooleanConstant
1325: .fromValue(left.intValue() >= right.intValue());
1326: case T_long:
1327: return BooleanConstant
1328: .fromValue(left.intValue() >= right.longValue());
1329: }
1330: break;
1331: case T_long:
1332: switch (rightId) {
1333: case T_char:
1334: return BooleanConstant
1335: .fromValue(left.longValue() >= right
1336: .charValue());
1337: case T_float:
1338: return BooleanConstant
1339: .fromValue(left.longValue() >= right
1340: .floatValue());
1341: case T_double:
1342: return BooleanConstant
1343: .fromValue(left.longValue() >= right
1344: .doubleValue());
1345: case T_byte:
1346: return BooleanConstant
1347: .fromValue(left.longValue() >= right
1348: .byteValue());
1349: case T_short:
1350: return BooleanConstant
1351: .fromValue(left.longValue() >= right
1352: .shortValue());
1353: case T_int:
1354: return BooleanConstant
1355: .fromValue(left.longValue() >= right.intValue());
1356: case T_long:
1357: return BooleanConstant
1358: .fromValue(left.longValue() >= right
1359: .longValue());
1360: }
1361:
1362: }
1363:
1364: return NotAConstant;
1365: }
1366:
1367: public static final Constant computeConstantOperationLEFT_SHIFT(
1368: Constant left, int leftId, Constant right, int rightId) {
1369:
1370: switch (leftId) {
1371: case T_char:
1372: switch (rightId) {
1373: case T_char:
1374: return IntConstant.fromValue(left.charValue() << right
1375: .charValue());
1376: case T_byte:
1377: return IntConstant.fromValue(left.charValue() << right
1378: .byteValue());
1379: case T_short:
1380: return IntConstant.fromValue(left.charValue() << right
1381: .shortValue());
1382: case T_int:
1383: return IntConstant.fromValue(left.charValue() << right
1384: .intValue());
1385: case T_long:
1386: return IntConstant.fromValue(left.charValue() << right
1387: .longValue());
1388: }
1389: break;
1390: case T_byte:
1391: switch (rightId) {
1392: case T_char:
1393: return IntConstant.fromValue(left.byteValue() << right
1394: .charValue());
1395: case T_byte:
1396: return IntConstant.fromValue(left.byteValue() << right
1397: .byteValue());
1398: case T_short:
1399: return IntConstant.fromValue(left.byteValue() << right
1400: .shortValue());
1401: case T_int:
1402: return IntConstant.fromValue(left.byteValue() << right
1403: .intValue());
1404: case T_long:
1405: return IntConstant.fromValue(left.byteValue() << right
1406: .longValue());
1407: }
1408: break;
1409: case T_short:
1410: switch (rightId) {
1411: case T_char:
1412: return IntConstant.fromValue(left.shortValue() << right
1413: .charValue());
1414: case T_byte:
1415: return IntConstant.fromValue(left.shortValue() << right
1416: .byteValue());
1417: case T_short:
1418: return IntConstant.fromValue(left.shortValue() << right
1419: .shortValue());
1420: case T_int:
1421: return IntConstant.fromValue(left.shortValue() << right
1422: .intValue());
1423: case T_long:
1424: return IntConstant.fromValue(left.shortValue() << right
1425: .longValue());
1426: }
1427: break;
1428: case T_int:
1429: switch (rightId) {
1430: case T_char:
1431: return IntConstant.fromValue(left.intValue() << right
1432: .charValue());
1433: case T_byte:
1434: return IntConstant.fromValue(left.intValue() << right
1435: .byteValue());
1436: case T_short:
1437: return IntConstant.fromValue(left.intValue() << right
1438: .shortValue());
1439: case T_int:
1440: return IntConstant.fromValue(left.intValue() << right
1441: .intValue());
1442: case T_long:
1443: return IntConstant.fromValue(left.intValue() << right
1444: .longValue());
1445: }
1446: break;
1447: case T_long:
1448: switch (rightId) {
1449: case T_char:
1450: return LongConstant.fromValue(left.longValue() << right
1451: .charValue());
1452: case T_byte:
1453: return LongConstant.fromValue(left.longValue() << right
1454: .byteValue());
1455: case T_short:
1456: return LongConstant.fromValue(left.longValue() << right
1457: .shortValue());
1458: case T_int:
1459: return LongConstant.fromValue(left.longValue() << right
1460: .intValue());
1461: case T_long:
1462: return LongConstant.fromValue(left.longValue() << right
1463: .longValue());
1464: }
1465:
1466: }
1467:
1468: return NotAConstant;
1469: }
1470:
1471: public static final Constant computeConstantOperationLESS(
1472: Constant left, int leftId, Constant right, int rightId) {
1473:
1474: switch (leftId) {
1475: case T_char:
1476: switch (rightId) {
1477: case T_char:
1478: return BooleanConstant
1479: .fromValue(left.charValue() < right.charValue());
1480: case T_float:
1481: return BooleanConstant
1482: .fromValue(left.charValue() < right
1483: .floatValue());
1484: case T_double:
1485: return BooleanConstant
1486: .fromValue(left.charValue() < right
1487: .doubleValue());
1488: case T_byte:
1489: return BooleanConstant
1490: .fromValue(left.charValue() < right.byteValue());
1491: case T_short:
1492: return BooleanConstant
1493: .fromValue(left.charValue() < right
1494: .shortValue());
1495: case T_int:
1496: return BooleanConstant
1497: .fromValue(left.charValue() < right.intValue());
1498: case T_long:
1499: return BooleanConstant
1500: .fromValue(left.charValue() < right.longValue());
1501: }
1502: break;
1503: case T_float:
1504: switch (rightId) {
1505: case T_char:
1506: return BooleanConstant
1507: .fromValue(left.floatValue() < right
1508: .charValue());
1509: case T_float:
1510: return BooleanConstant
1511: .fromValue(left.floatValue() < right
1512: .floatValue());
1513: case T_double:
1514: return BooleanConstant
1515: .fromValue(left.floatValue() < right
1516: .doubleValue());
1517: case T_byte:
1518: return BooleanConstant
1519: .fromValue(left.floatValue() < right
1520: .byteValue());
1521: case T_short:
1522: return BooleanConstant
1523: .fromValue(left.floatValue() < right
1524: .shortValue());
1525: case T_int:
1526: return BooleanConstant
1527: .fromValue(left.floatValue() < right.intValue());
1528: case T_long:
1529: return BooleanConstant
1530: .fromValue(left.floatValue() < right
1531: .longValue());
1532: }
1533: break;
1534: case T_double:
1535: switch (rightId) {
1536: case T_char:
1537: return BooleanConstant
1538: .fromValue(left.doubleValue() < right
1539: .charValue());
1540: case T_float:
1541: return BooleanConstant
1542: .fromValue(left.doubleValue() < right
1543: .floatValue());
1544: case T_double:
1545: return BooleanConstant
1546: .fromValue(left.doubleValue() < right
1547: .doubleValue());
1548: case T_byte:
1549: return BooleanConstant
1550: .fromValue(left.doubleValue() < right
1551: .byteValue());
1552: case T_short:
1553: return BooleanConstant
1554: .fromValue(left.doubleValue() < right
1555: .shortValue());
1556: case T_int:
1557: return BooleanConstant
1558: .fromValue(left.doubleValue() < right
1559: .intValue());
1560: case T_long:
1561: return BooleanConstant
1562: .fromValue(left.doubleValue() < right
1563: .longValue());
1564: }
1565: break;
1566: case T_byte:
1567: switch (rightId) {
1568: case T_char:
1569: return BooleanConstant
1570: .fromValue(left.byteValue() < right.charValue());
1571: case T_float:
1572: return BooleanConstant
1573: .fromValue(left.byteValue() < right
1574: .floatValue());
1575: case T_double:
1576: return BooleanConstant
1577: .fromValue(left.byteValue() < right
1578: .doubleValue());
1579: case T_byte:
1580: return BooleanConstant
1581: .fromValue(left.byteValue() < right.byteValue());
1582: case T_short:
1583: return BooleanConstant
1584: .fromValue(left.byteValue() < right
1585: .shortValue());
1586: case T_int:
1587: return BooleanConstant
1588: .fromValue(left.byteValue() < right.intValue());
1589: case T_long:
1590: return BooleanConstant
1591: .fromValue(left.byteValue() < right.longValue());
1592: }
1593: break;
1594: case T_short:
1595: switch (rightId) {
1596: case T_char:
1597: return BooleanConstant
1598: .fromValue(left.shortValue() < right
1599: .charValue());
1600: case T_float:
1601: return BooleanConstant
1602: .fromValue(left.shortValue() < right
1603: .floatValue());
1604: case T_double:
1605: return BooleanConstant
1606: .fromValue(left.shortValue() < right
1607: .doubleValue());
1608: case T_byte:
1609: return BooleanConstant
1610: .fromValue(left.shortValue() < right
1611: .byteValue());
1612: case T_short:
1613: return BooleanConstant
1614: .fromValue(left.shortValue() < right
1615: .shortValue());
1616: case T_int:
1617: return BooleanConstant
1618: .fromValue(left.shortValue() < right.intValue());
1619: case T_long:
1620: return BooleanConstant
1621: .fromValue(left.shortValue() < right
1622: .longValue());
1623: }
1624: break;
1625: case T_int:
1626: switch (rightId) {
1627: case T_char:
1628: return BooleanConstant
1629: .fromValue(left.intValue() < right.charValue());
1630: case T_float:
1631: return BooleanConstant
1632: .fromValue(left.intValue() < right.floatValue());
1633: case T_double:
1634: return BooleanConstant
1635: .fromValue(left.intValue() < right
1636: .doubleValue());
1637: case T_byte:
1638: return BooleanConstant
1639: .fromValue(left.intValue() < right.byteValue());
1640: case T_short:
1641: return BooleanConstant
1642: .fromValue(left.intValue() < right.shortValue());
1643: case T_int:
1644: return BooleanConstant
1645: .fromValue(left.intValue() < right.intValue());
1646: case T_long:
1647: return BooleanConstant
1648: .fromValue(left.intValue() < right.longValue());
1649: }
1650: break;
1651: case T_long:
1652: switch (rightId) {
1653: case T_char:
1654: return BooleanConstant
1655: .fromValue(left.longValue() < right.charValue());
1656: case T_float:
1657: return BooleanConstant
1658: .fromValue(left.longValue() < right
1659: .floatValue());
1660: case T_double:
1661: return BooleanConstant
1662: .fromValue(left.longValue() < right
1663: .doubleValue());
1664: case T_byte:
1665: return BooleanConstant
1666: .fromValue(left.longValue() < right.byteValue());
1667: case T_short:
1668: return BooleanConstant
1669: .fromValue(left.longValue() < right
1670: .shortValue());
1671: case T_int:
1672: return BooleanConstant
1673: .fromValue(left.longValue() < right.intValue());
1674: case T_long:
1675: return BooleanConstant
1676: .fromValue(left.longValue() < right.longValue());
1677: }
1678:
1679: }
1680:
1681: return NotAConstant;
1682: }
1683:
1684: public static final Constant computeConstantOperationLESS_EQUAL(
1685: Constant left, int leftId, Constant right, int rightId) {
1686:
1687: switch (leftId) {
1688: case T_char:
1689: switch (rightId) {
1690: case T_char:
1691: return BooleanConstant
1692: .fromValue(left.charValue() <= right
1693: .charValue());
1694: case T_float:
1695: return BooleanConstant
1696: .fromValue(left.charValue() <= right
1697: .floatValue());
1698: case T_double:
1699: return BooleanConstant
1700: .fromValue(left.charValue() <= right
1701: .doubleValue());
1702: case T_byte:
1703: return BooleanConstant
1704: .fromValue(left.charValue() <= right
1705: .byteValue());
1706: case T_short:
1707: return BooleanConstant
1708: .fromValue(left.charValue() <= right
1709: .shortValue());
1710: case T_int:
1711: return BooleanConstant
1712: .fromValue(left.charValue() <= right.intValue());
1713: case T_long:
1714: return BooleanConstant
1715: .fromValue(left.charValue() <= right
1716: .longValue());
1717: }
1718: break;
1719: case T_float:
1720: switch (rightId) {
1721: case T_char:
1722: return BooleanConstant
1723: .fromValue(left.floatValue() <= right
1724: .charValue());
1725: case T_float:
1726: return BooleanConstant
1727: .fromValue(left.floatValue() <= right
1728: .floatValue());
1729: case T_double:
1730: return BooleanConstant
1731: .fromValue(left.floatValue() <= right
1732: .doubleValue());
1733: case T_byte:
1734: return BooleanConstant
1735: .fromValue(left.floatValue() <= right
1736: .byteValue());
1737: case T_short:
1738: return BooleanConstant
1739: .fromValue(left.floatValue() <= right
1740: .shortValue());
1741: case T_int:
1742: return BooleanConstant
1743: .fromValue(left.floatValue() <= right
1744: .intValue());
1745: case T_long:
1746: return BooleanConstant
1747: .fromValue(left.floatValue() <= right
1748: .longValue());
1749: }
1750: break;
1751: case T_double:
1752: switch (rightId) {
1753: case T_char:
1754: return BooleanConstant
1755: .fromValue(left.doubleValue() <= right
1756: .charValue());
1757: case T_float:
1758: return BooleanConstant
1759: .fromValue(left.doubleValue() <= right
1760: .floatValue());
1761: case T_double:
1762: return BooleanConstant
1763: .fromValue(left.doubleValue() <= right
1764: .doubleValue());
1765: case T_byte:
1766: return BooleanConstant
1767: .fromValue(left.doubleValue() <= right
1768: .byteValue());
1769: case T_short:
1770: return BooleanConstant
1771: .fromValue(left.doubleValue() <= right
1772: .shortValue());
1773: case T_int:
1774: return BooleanConstant
1775: .fromValue(left.doubleValue() <= right
1776: .intValue());
1777: case T_long:
1778: return BooleanConstant
1779: .fromValue(left.doubleValue() <= right
1780: .longValue());
1781: }
1782: break;
1783: case T_byte:
1784: switch (rightId) {
1785: case T_char:
1786: return BooleanConstant
1787: .fromValue(left.byteValue() <= right
1788: .charValue());
1789: case T_float:
1790: return BooleanConstant
1791: .fromValue(left.byteValue() <= right
1792: .floatValue());
1793: case T_double:
1794: return BooleanConstant
1795: .fromValue(left.byteValue() <= right
1796: .doubleValue());
1797: case T_byte:
1798: return BooleanConstant
1799: .fromValue(left.byteValue() <= right
1800: .byteValue());
1801: case T_short:
1802: return BooleanConstant
1803: .fromValue(left.byteValue() <= right
1804: .shortValue());
1805: case T_int:
1806: return BooleanConstant
1807: .fromValue(left.byteValue() <= right.intValue());
1808: case T_long:
1809: return BooleanConstant
1810: .fromValue(left.byteValue() <= right
1811: .longValue());
1812: }
1813: break;
1814: case T_short:
1815: switch (rightId) {
1816: case T_char:
1817: return BooleanConstant
1818: .fromValue(left.shortValue() <= right
1819: .charValue());
1820: case T_float:
1821: return BooleanConstant
1822: .fromValue(left.shortValue() <= right
1823: .floatValue());
1824: case T_double:
1825: return BooleanConstant
1826: .fromValue(left.shortValue() <= right
1827: .doubleValue());
1828: case T_byte:
1829: return BooleanConstant
1830: .fromValue(left.shortValue() <= right
1831: .byteValue());
1832: case T_short:
1833: return BooleanConstant
1834: .fromValue(left.shortValue() <= right
1835: .shortValue());
1836: case T_int:
1837: return BooleanConstant
1838: .fromValue(left.shortValue() <= right
1839: .intValue());
1840: case T_long:
1841: return BooleanConstant
1842: .fromValue(left.shortValue() <= right
1843: .longValue());
1844: }
1845: break;
1846: case T_int:
1847: switch (rightId) {
1848: case T_char:
1849: return BooleanConstant
1850: .fromValue(left.intValue() <= right.charValue());
1851: case T_float:
1852: return BooleanConstant
1853: .fromValue(left.intValue() <= right
1854: .floatValue());
1855: case T_double:
1856: return BooleanConstant
1857: .fromValue(left.intValue() <= right
1858: .doubleValue());
1859: case T_byte:
1860: return BooleanConstant
1861: .fromValue(left.intValue() <= right.byteValue());
1862: case T_short:
1863: return BooleanConstant
1864: .fromValue(left.intValue() <= right
1865: .shortValue());
1866: case T_int:
1867: return BooleanConstant
1868: .fromValue(left.intValue() <= right.intValue());
1869: case T_long:
1870: return BooleanConstant
1871: .fromValue(left.intValue() <= right.longValue());
1872: }
1873: break;
1874: case T_long:
1875: switch (rightId) {
1876: case T_char:
1877: return BooleanConstant
1878: .fromValue(left.longValue() <= right
1879: .charValue());
1880: case T_float:
1881: return BooleanConstant
1882: .fromValue(left.longValue() <= right
1883: .floatValue());
1884: case T_double:
1885: return BooleanConstant
1886: .fromValue(left.longValue() <= right
1887: .doubleValue());
1888: case T_byte:
1889: return BooleanConstant
1890: .fromValue(left.longValue() <= right
1891: .byteValue());
1892: case T_short:
1893: return BooleanConstant
1894: .fromValue(left.longValue() <= right
1895: .shortValue());
1896: case T_int:
1897: return BooleanConstant
1898: .fromValue(left.longValue() <= right.intValue());
1899: case T_long:
1900: return BooleanConstant
1901: .fromValue(left.longValue() <= right
1902: .longValue());
1903: }
1904: }
1905:
1906: return NotAConstant;
1907: }
1908:
1909: public static final Constant computeConstantOperationMINUS(
1910: Constant left, int leftId, Constant right, int rightId) {
1911:
1912: switch (leftId) {
1913: case T_char:
1914: switch (rightId) {
1915: case T_char:
1916: return IntConstant.fromValue(left.charValue()
1917: - right.charValue());
1918: case T_float:
1919: return FloatConstant.fromValue(left.charValue()
1920: - right.floatValue());
1921: case T_double:
1922: return DoubleConstant.fromValue(left.charValue()
1923: - right.doubleValue());
1924: case T_byte:
1925: return IntConstant.fromValue(left.charValue()
1926: - right.byteValue());
1927: case T_short:
1928: return IntConstant.fromValue(left.charValue()
1929: - right.shortValue());
1930: case T_int:
1931: return IntConstant.fromValue(left.charValue()
1932: - right.intValue());
1933: case T_long:
1934: return LongConstant.fromValue(left.charValue()
1935: - right.longValue());
1936: }
1937: break;
1938: case T_float:
1939: switch (rightId) {
1940: case T_char:
1941: return FloatConstant.fromValue(left.floatValue()
1942: - right.charValue());
1943: case T_float:
1944: return FloatConstant.fromValue(left.floatValue()
1945: - right.floatValue());
1946: case T_double:
1947: return DoubleConstant.fromValue(left.floatValue()
1948: - right.doubleValue());
1949: case T_byte:
1950: return FloatConstant.fromValue(left.floatValue()
1951: - right.byteValue());
1952: case T_short:
1953: return FloatConstant.fromValue(left.floatValue()
1954: - right.shortValue());
1955: case T_int:
1956: return FloatConstant.fromValue(left.floatValue()
1957: - right.intValue());
1958: case T_long:
1959: return FloatConstant.fromValue(left.floatValue()
1960: - right.longValue());
1961: }
1962: break;
1963: case T_double:
1964: switch (rightId) {
1965: case T_char:
1966: return DoubleConstant.fromValue(left.doubleValue()
1967: - right.charValue());
1968: case T_float:
1969: return DoubleConstant.fromValue(left.doubleValue()
1970: - right.floatValue());
1971: case T_double:
1972: return DoubleConstant.fromValue(left.doubleValue()
1973: - right.doubleValue());
1974: case T_byte:
1975: return DoubleConstant.fromValue(left.doubleValue()
1976: - right.byteValue());
1977: case T_short:
1978: return DoubleConstant.fromValue(left.doubleValue()
1979: - right.shortValue());
1980: case T_int:
1981: return DoubleConstant.fromValue(left.doubleValue()
1982: - right.intValue());
1983: case T_long:
1984: return DoubleConstant.fromValue(left.doubleValue()
1985: - right.longValue());
1986: }
1987: break;
1988: case T_byte:
1989: switch (rightId) {
1990: case T_char:
1991: return IntConstant.fromValue(left.byteValue()
1992: - right.charValue());
1993: case T_float:
1994: return FloatConstant.fromValue(left.byteValue()
1995: - right.floatValue());
1996: case T_double:
1997: return DoubleConstant.fromValue(left.byteValue()
1998: - right.doubleValue());
1999: case T_byte:
2000: return IntConstant.fromValue(left.byteValue()
2001: - right.byteValue());
2002: case T_short:
2003: return IntConstant.fromValue(left.byteValue()
2004: - right.shortValue());
2005: case T_int:
2006: return IntConstant.fromValue(left.byteValue()
2007: - right.intValue());
2008: case T_long:
2009: return LongConstant.fromValue(left.byteValue()
2010: - right.longValue());
2011: }
2012: break;
2013: case T_short:
2014: switch (rightId) {
2015: case T_char:
2016: return IntConstant.fromValue(left.shortValue()
2017: - right.charValue());
2018: case T_float:
2019: return FloatConstant.fromValue(left.shortValue()
2020: - right.floatValue());
2021: case T_double:
2022: return DoubleConstant.fromValue(left.shortValue()
2023: - right.doubleValue());
2024: case T_byte:
2025: return IntConstant.fromValue(left.shortValue()
2026: - right.byteValue());
2027: case T_short:
2028: return IntConstant.fromValue(left.shortValue()
2029: - right.shortValue());
2030: case T_int:
2031: return IntConstant.fromValue(left.shortValue()
2032: - right.intValue());
2033: case T_long:
2034: return LongConstant.fromValue(left.shortValue()
2035: - right.longValue());
2036: }
2037: break;
2038: case T_int:
2039: switch (rightId) {
2040: case T_char:
2041: return IntConstant.fromValue(left.intValue()
2042: - right.charValue());
2043: case T_float:
2044: return FloatConstant.fromValue(left.intValue()
2045: - right.floatValue());
2046: case T_double:
2047: return DoubleConstant.fromValue(left.intValue()
2048: - right.doubleValue());
2049: case T_byte:
2050: return IntConstant.fromValue(left.intValue()
2051: - right.byteValue());
2052: case T_short:
2053: return IntConstant.fromValue(left.intValue()
2054: - right.shortValue());
2055: case T_int:
2056: return IntConstant.fromValue(left.intValue()
2057: - right.intValue());
2058: case T_long:
2059: return LongConstant.fromValue(left.intValue()
2060: - right.longValue());
2061: }
2062: break;
2063: case T_long:
2064: switch (rightId) {
2065: case T_char:
2066: return LongConstant.fromValue(left.longValue()
2067: - right.charValue());
2068: case T_float:
2069: return FloatConstant.fromValue(left.longValue()
2070: - right.floatValue());
2071: case T_double:
2072: return DoubleConstant.fromValue(left.longValue()
2073: - right.doubleValue());
2074: case T_byte:
2075: return LongConstant.fromValue(left.longValue()
2076: - right.byteValue());
2077: case T_short:
2078: return LongConstant.fromValue(left.longValue()
2079: - right.shortValue());
2080: case T_int:
2081: return LongConstant.fromValue(left.longValue()
2082: - right.intValue());
2083: case T_long:
2084: return LongConstant.fromValue(left.longValue()
2085: - right.longValue());
2086: }
2087:
2088: }
2089:
2090: return NotAConstant;
2091: }
2092:
2093: public static final Constant computeConstantOperationMULTIPLY(
2094: Constant left, int leftId, Constant right, int rightId) {
2095:
2096: switch (leftId) {
2097: case T_char:
2098: switch (rightId) {
2099: case T_char:
2100: return IntConstant.fromValue(left.charValue()
2101: * right.charValue());
2102: case T_float:
2103: return FloatConstant.fromValue(left.charValue()
2104: * right.floatValue());
2105: case T_double:
2106: return DoubleConstant.fromValue(left.charValue()
2107: * right.doubleValue());
2108: case T_byte:
2109: return IntConstant.fromValue(left.charValue()
2110: * right.byteValue());
2111: case T_short:
2112: return IntConstant.fromValue(left.charValue()
2113: * right.shortValue());
2114: case T_int:
2115: return IntConstant.fromValue(left.charValue()
2116: * right.intValue());
2117: case T_long:
2118: return LongConstant.fromValue(left.charValue()
2119: * right.longValue());
2120: }
2121: break;
2122: case T_float:
2123: switch (rightId) {
2124: case T_char:
2125: return FloatConstant.fromValue(left.floatValue()
2126: * right.charValue());
2127: case T_float:
2128: return FloatConstant.fromValue(left.floatValue()
2129: * right.floatValue());
2130: case T_double:
2131: return DoubleConstant.fromValue(left.floatValue()
2132: * right.doubleValue());
2133: case T_byte:
2134: return FloatConstant.fromValue(left.floatValue()
2135: * right.byteValue());
2136: case T_short:
2137: return FloatConstant.fromValue(left.floatValue()
2138: * right.shortValue());
2139: case T_int:
2140: return FloatConstant.fromValue(left.floatValue()
2141: * right.intValue());
2142: case T_long:
2143: return FloatConstant.fromValue(left.floatValue()
2144: * right.longValue());
2145: }
2146: break;
2147: case T_double:
2148: switch (rightId) {
2149: case T_char:
2150: return DoubleConstant.fromValue(left.doubleValue()
2151: * right.charValue());
2152: case T_float:
2153: return DoubleConstant.fromValue(left.doubleValue()
2154: * right.floatValue());
2155: case T_double:
2156: return DoubleConstant.fromValue(left.doubleValue()
2157: * right.doubleValue());
2158: case T_byte:
2159: return DoubleConstant.fromValue(left.doubleValue()
2160: * right.byteValue());
2161: case T_short:
2162: return DoubleConstant.fromValue(left.doubleValue()
2163: * right.shortValue());
2164: case T_int:
2165: return DoubleConstant.fromValue(left.doubleValue()
2166: * right.intValue());
2167: case T_long:
2168: return DoubleConstant.fromValue(left.doubleValue()
2169: * right.longValue());
2170: }
2171: break;
2172: case T_byte:
2173: switch (rightId) {
2174: case T_char:
2175: return IntConstant.fromValue(left.byteValue()
2176: * right.charValue());
2177: case T_float:
2178: return FloatConstant.fromValue(left.byteValue()
2179: * right.floatValue());
2180: case T_double:
2181: return DoubleConstant.fromValue(left.byteValue()
2182: * right.doubleValue());
2183: case T_byte:
2184: return IntConstant.fromValue(left.byteValue()
2185: * right.byteValue());
2186: case T_short:
2187: return IntConstant.fromValue(left.byteValue()
2188: * right.shortValue());
2189: case T_int:
2190: return IntConstant.fromValue(left.byteValue()
2191: * right.intValue());
2192: case T_long:
2193: return LongConstant.fromValue(left.byteValue()
2194: * right.longValue());
2195: }
2196: break;
2197: case T_short:
2198: switch (rightId) {
2199: case T_char:
2200: return IntConstant.fromValue(left.shortValue()
2201: * right.charValue());
2202: case T_float:
2203: return FloatConstant.fromValue(left.shortValue()
2204: * right.floatValue());
2205: case T_double:
2206: return DoubleConstant.fromValue(left.shortValue()
2207: * right.doubleValue());
2208: case T_byte:
2209: return IntConstant.fromValue(left.shortValue()
2210: * right.byteValue());
2211: case T_short:
2212: return IntConstant.fromValue(left.shortValue()
2213: * right.shortValue());
2214: case T_int:
2215: return IntConstant.fromValue(left.shortValue()
2216: * right.intValue());
2217: case T_long:
2218: return LongConstant.fromValue(left.shortValue()
2219: * right.longValue());
2220: }
2221: break;
2222: case T_int:
2223: switch (rightId) {
2224: case T_char:
2225: return IntConstant.fromValue(left.intValue()
2226: * right.charValue());
2227: case T_float:
2228: return FloatConstant.fromValue(left.intValue()
2229: * right.floatValue());
2230: case T_double:
2231: return DoubleConstant.fromValue(left.intValue()
2232: * right.doubleValue());
2233: case T_byte:
2234: return IntConstant.fromValue(left.intValue()
2235: * right.byteValue());
2236: case T_short:
2237: return IntConstant.fromValue(left.intValue()
2238: * right.shortValue());
2239: case T_int:
2240: return IntConstant.fromValue(left.intValue()
2241: * right.intValue());
2242: case T_long:
2243: return LongConstant.fromValue(left.intValue()
2244: * right.longValue());
2245: }
2246: break;
2247: case T_long:
2248: switch (rightId) {
2249: case T_char:
2250: return LongConstant.fromValue(left.longValue()
2251: * right.charValue());
2252: case T_float:
2253: return FloatConstant.fromValue(left.longValue()
2254: * right.floatValue());
2255: case T_double:
2256: return DoubleConstant.fromValue(left.longValue()
2257: * right.doubleValue());
2258: case T_byte:
2259: return LongConstant.fromValue(left.longValue()
2260: * right.byteValue());
2261: case T_short:
2262: return LongConstant.fromValue(left.longValue()
2263: * right.shortValue());
2264: case T_int:
2265: return LongConstant.fromValue(left.longValue()
2266: * right.intValue());
2267: case T_long:
2268: return LongConstant.fromValue(left.longValue()
2269: * right.longValue());
2270: }
2271: }
2272:
2273: return NotAConstant;
2274: }
2275:
2276: public static final Constant computeConstantOperationOR(
2277: Constant left, int leftId, Constant right, int rightId) {
2278:
2279: switch (leftId) {
2280: case T_boolean:
2281: return BooleanConstant.fromValue(left.booleanValue()
2282: | right.booleanValue());
2283: case T_char:
2284: switch (rightId) {
2285: case T_char:
2286: return IntConstant.fromValue(left.charValue()
2287: | right.charValue());
2288: case T_byte:
2289: return IntConstant.fromValue(left.charValue()
2290: | right.byteValue());
2291: case T_short:
2292: return IntConstant.fromValue(left.charValue()
2293: | right.shortValue());
2294: case T_int:
2295: return IntConstant.fromValue(left.charValue()
2296: | right.intValue());
2297: case T_long:
2298: return LongConstant.fromValue(left.charValue()
2299: | right.longValue());
2300: }
2301: break;
2302: case T_byte:
2303: switch (rightId) {
2304: case T_char:
2305: return IntConstant.fromValue(left.byteValue()
2306: | right.charValue());
2307: case T_byte:
2308: return IntConstant.fromValue(left.byteValue()
2309: | right.byteValue());
2310: case T_short:
2311: return IntConstant.fromValue(left.byteValue()
2312: | right.shortValue());
2313: case T_int:
2314: return IntConstant.fromValue(left.byteValue()
2315: | right.intValue());
2316: case T_long:
2317: return LongConstant.fromValue(left.byteValue()
2318: | right.longValue());
2319: }
2320: break;
2321: case T_short:
2322: switch (rightId) {
2323: case T_char:
2324: return IntConstant.fromValue(left.shortValue()
2325: | right.charValue());
2326: case T_byte:
2327: return IntConstant.fromValue(left.shortValue()
2328: | right.byteValue());
2329: case T_short:
2330: return IntConstant.fromValue(left.shortValue()
2331: | right.shortValue());
2332: case T_int:
2333: return IntConstant.fromValue(left.shortValue()
2334: | right.intValue());
2335: case T_long:
2336: return LongConstant.fromValue(left.shortValue()
2337: | right.longValue());
2338: }
2339: break;
2340: case T_int:
2341: switch (rightId) {
2342: case T_char:
2343: return IntConstant.fromValue(left.intValue()
2344: | right.charValue());
2345: case T_byte:
2346: return IntConstant.fromValue(left.intValue()
2347: | right.byteValue());
2348: case T_short:
2349: return IntConstant.fromValue(left.intValue()
2350: | right.shortValue());
2351: case T_int:
2352: return IntConstant.fromValue(left.intValue()
2353: | right.intValue());
2354: case T_long:
2355: return LongConstant.fromValue(left.intValue()
2356: | right.longValue());
2357: }
2358: break;
2359: case T_long:
2360: switch (rightId) {
2361: case T_char:
2362: return LongConstant.fromValue(left.longValue()
2363: | right.charValue());
2364: case T_byte:
2365: return LongConstant.fromValue(left.longValue()
2366: | right.byteValue());
2367: case T_short:
2368: return LongConstant.fromValue(left.longValue()
2369: | right.shortValue());
2370: case T_int:
2371: return LongConstant.fromValue(left.longValue()
2372: | right.intValue());
2373: case T_long:
2374: return LongConstant.fromValue(left.longValue()
2375: | right.longValue());
2376: }
2377:
2378: }
2379:
2380: return NotAConstant;
2381: }
2382:
2383: public static final Constant computeConstantOperationOR_OR(
2384: Constant left, int leftId, Constant right, int rightId) {
2385:
2386: return BooleanConstant.fromValue(left.booleanValue()
2387: || right.booleanValue());
2388: }
2389:
2390: public static final Constant computeConstantOperationPLUS(
2391: Constant left, int leftId, Constant right, int rightId) {
2392:
2393: switch (leftId) {
2394: case T_JavaLangObject:
2395: if (rightId == T_JavaLangString) {
2396: return StringConstant.fromValue(left.stringValue()
2397: + right.stringValue());
2398: }
2399: case T_boolean:
2400: if (rightId == T_JavaLangString) {
2401: return StringConstant.fromValue(left.stringValue()
2402: + right.stringValue());
2403: }
2404: break;
2405: case T_char:
2406: switch (rightId) {
2407: case T_char:
2408: return IntConstant.fromValue(left.charValue()
2409: + right.charValue());
2410: case T_float:
2411: return FloatConstant.fromValue(left.charValue()
2412: + right.floatValue());
2413: case T_double:
2414: return DoubleConstant.fromValue(left.charValue()
2415: + right.doubleValue());
2416: case T_byte:
2417: return IntConstant.fromValue(left.charValue()
2418: + right.byteValue());
2419: case T_short:
2420: return IntConstant.fromValue(left.charValue()
2421: + right.shortValue());
2422: case T_int:
2423: return IntConstant.fromValue(left.charValue()
2424: + right.intValue());
2425: case T_long:
2426: return LongConstant.fromValue(left.charValue()
2427: + right.longValue());
2428: case T_JavaLangString:
2429: return StringConstant.fromValue(left.stringValue()
2430: + right.stringValue());
2431: }
2432: break;
2433: case T_float:
2434: switch (rightId) {
2435: case T_char:
2436: return FloatConstant.fromValue(left.floatValue()
2437: + right.charValue());
2438: case T_float:
2439: return FloatConstant.fromValue(left.floatValue()
2440: + right.floatValue());
2441: case T_double:
2442: return DoubleConstant.fromValue(left.floatValue()
2443: + right.doubleValue());
2444: case T_byte:
2445: return FloatConstant.fromValue(left.floatValue()
2446: + right.byteValue());
2447: case T_short:
2448: return FloatConstant.fromValue(left.floatValue()
2449: + right.shortValue());
2450: case T_int:
2451: return FloatConstant.fromValue(left.floatValue()
2452: + right.intValue());
2453: case T_long:
2454: return FloatConstant.fromValue(left.floatValue()
2455: + right.longValue());
2456: case T_JavaLangString:
2457: return StringConstant.fromValue(left.stringValue()
2458: + right.stringValue());
2459: }
2460: break;
2461: case T_double:
2462: switch (rightId) {
2463: case T_char:
2464: return DoubleConstant.fromValue(left.doubleValue()
2465: + right.charValue());
2466: case T_float:
2467: return DoubleConstant.fromValue(left.doubleValue()
2468: + right.floatValue());
2469: case T_double:
2470: return DoubleConstant.fromValue(left.doubleValue()
2471: + right.doubleValue());
2472: case T_byte:
2473: return DoubleConstant.fromValue(left.doubleValue()
2474: + right.byteValue());
2475: case T_short:
2476: return DoubleConstant.fromValue(left.doubleValue()
2477: + right.shortValue());
2478: case T_int:
2479: return DoubleConstant.fromValue(left.doubleValue()
2480: + right.intValue());
2481: case T_long:
2482: return DoubleConstant.fromValue(left.doubleValue()
2483: + right.longValue());
2484: case T_JavaLangString:
2485: return StringConstant.fromValue(left.stringValue()
2486: + right.stringValue());
2487: }
2488: break;
2489: case T_byte:
2490: switch (rightId) {
2491: case T_char:
2492: return IntConstant.fromValue(left.byteValue()
2493: + right.charValue());
2494: case T_float:
2495: return FloatConstant.fromValue(left.byteValue()
2496: + right.floatValue());
2497: case T_double:
2498: return DoubleConstant.fromValue(left.byteValue()
2499: + right.doubleValue());
2500: case T_byte:
2501: return IntConstant.fromValue(left.byteValue()
2502: + right.byteValue());
2503: case T_short:
2504: return IntConstant.fromValue(left.byteValue()
2505: + right.shortValue());
2506: case T_int:
2507: return IntConstant.fromValue(left.byteValue()
2508: + right.intValue());
2509: case T_long:
2510: return LongConstant.fromValue(left.byteValue()
2511: + right.longValue());
2512: case T_JavaLangString:
2513: return StringConstant.fromValue(left.stringValue()
2514: + right.stringValue());
2515: }
2516:
2517: break;
2518: case T_short:
2519: switch (rightId) {
2520: case T_char:
2521: return IntConstant.fromValue(left.shortValue()
2522: + right.charValue());
2523: case T_float:
2524: return FloatConstant.fromValue(left.shortValue()
2525: + right.floatValue());
2526: case T_double:
2527: return DoubleConstant.fromValue(left.shortValue()
2528: + right.doubleValue());
2529: case T_byte:
2530: return IntConstant.fromValue(left.shortValue()
2531: + right.byteValue());
2532: case T_short:
2533: return IntConstant.fromValue(left.shortValue()
2534: + right.shortValue());
2535: case T_int:
2536: return IntConstant.fromValue(left.shortValue()
2537: + right.intValue());
2538: case T_long:
2539: return LongConstant.fromValue(left.shortValue()
2540: + right.longValue());
2541: case T_JavaLangString:
2542: return StringConstant.fromValue(left.stringValue()
2543: + right.stringValue());
2544: }
2545: break;
2546: case T_int:
2547: switch (rightId) {
2548: case T_char:
2549: return IntConstant.fromValue(left.intValue()
2550: + right.charValue());
2551: case T_float:
2552: return FloatConstant.fromValue(left.intValue()
2553: + right.floatValue());
2554: case T_double:
2555: return DoubleConstant.fromValue(left.intValue()
2556: + right.doubleValue());
2557: case T_byte:
2558: return IntConstant.fromValue(left.intValue()
2559: + right.byteValue());
2560: case T_short:
2561: return IntConstant.fromValue(left.intValue()
2562: + right.shortValue());
2563: case T_int:
2564: return IntConstant.fromValue(left.intValue()
2565: + right.intValue());
2566: case T_long:
2567: return LongConstant.fromValue(left.intValue()
2568: + right.longValue());
2569: case T_JavaLangString:
2570: return StringConstant.fromValue(left.stringValue()
2571: + right.stringValue());
2572: }
2573: break;
2574: case T_long:
2575: switch (rightId) {
2576: case T_char:
2577: return LongConstant.fromValue(left.longValue()
2578: + right.charValue());
2579: case T_float:
2580: return FloatConstant.fromValue(left.longValue()
2581: + right.floatValue());
2582: case T_double:
2583: return DoubleConstant.fromValue(left.longValue()
2584: + right.doubleValue());
2585: case T_byte:
2586: return LongConstant.fromValue(left.longValue()
2587: + right.byteValue());
2588: case T_short:
2589: return LongConstant.fromValue(left.longValue()
2590: + right.shortValue());
2591: case T_int:
2592: return LongConstant.fromValue(left.longValue()
2593: + right.intValue());
2594: case T_long:
2595: return LongConstant.fromValue(left.longValue()
2596: + right.longValue());
2597: case T_JavaLangString:
2598: return StringConstant.fromValue(left.stringValue()
2599: + right.stringValue());
2600: }
2601: break;
2602: case T_JavaLangString:
2603: switch (rightId) {
2604: case T_char:
2605: return StringConstant.fromValue(left.stringValue()
2606: + String.valueOf(right.charValue()));
2607: case T_float:
2608: return StringConstant.fromValue(left.stringValue()
2609: + String.valueOf(right.floatValue()));
2610: case T_double:
2611: return StringConstant.fromValue(left.stringValue()
2612: + String.valueOf(right.doubleValue()));
2613: case T_byte:
2614: return StringConstant.fromValue(left.stringValue()
2615: + String.valueOf(right.byteValue()));
2616: case T_short:
2617: return StringConstant.fromValue(left.stringValue()
2618: + String.valueOf(right.shortValue()));
2619: case T_int:
2620: return StringConstant.fromValue(left.stringValue()
2621: + String.valueOf(right.intValue()));
2622: case T_long:
2623: return StringConstant.fromValue(left.stringValue()
2624: + String.valueOf(right.longValue()));
2625: case T_JavaLangString:
2626: return StringConstant.fromValue(left.stringValue()
2627: + right.stringValue());
2628: case T_boolean:
2629: return StringConstant.fromValue(left.stringValue()
2630: + right.booleanValue());
2631: }
2632: break;
2633: // case T_null :
2634: // switch (rightId){
2635: // case T_char : return Constant.fromValue(left.stringValue() + String.valueOf(right.charValue()));
2636: // case T_float: return Constant.fromValue(left.stringValue() + String.valueOf(right.floatValue()));
2637: // case T_double: return Constant.fromValue(left.stringValue() + String.valueOf(right.doubleValue()));
2638: // case T_byte: return Constant.fromValue(left.stringValue() + String.valueOf(right.byteValue()));
2639: // case T_short: return Constant.fromValue(left.stringValue() + String.valueOf(right.shortValue()));
2640: // case T_int: return Constant.fromValue(left.stringValue() + String.valueOf(right.intValue()));
2641: // case T_long: return Constant.fromValue(left.stringValue() + String.valueOf(right.longValue()));
2642: // case T_JavaLangString: return Constant.fromValue(left.stringValue() + right.stringValue());
2643: // case T_boolean: return Constant.fromValue(left.stringValue() + right.booleanValue());
2644: // }
2645: }
2646:
2647: return NotAConstant;
2648: }
2649:
2650: public static final Constant computeConstantOperationREMAINDER(
2651: Constant left, int leftId, Constant right, int rightId) {
2652:
2653: switch (leftId) {
2654: case T_char:
2655: switch (rightId) {
2656: case T_char:
2657: return IntConstant.fromValue(left.charValue()
2658: % right.charValue());
2659: case T_float:
2660: return FloatConstant.fromValue(left.charValue()
2661: % right.floatValue());
2662: case T_double:
2663: return DoubleConstant.fromValue(left.charValue()
2664: % right.doubleValue());
2665: case T_byte:
2666: return IntConstant.fromValue(left.charValue()
2667: % right.byteValue());
2668: case T_short:
2669: return IntConstant.fromValue(left.charValue()
2670: % right.shortValue());
2671: case T_int:
2672: return IntConstant.fromValue(left.charValue()
2673: % right.intValue());
2674: case T_long:
2675: return LongConstant.fromValue(left.charValue()
2676: % right.longValue());
2677: }
2678: break;
2679: case T_float:
2680: switch (rightId) {
2681: case T_char:
2682: return FloatConstant.fromValue(left.floatValue()
2683: % right.charValue());
2684: case T_float:
2685: return FloatConstant.fromValue(left.floatValue()
2686: % right.floatValue());
2687: case T_double:
2688: return DoubleConstant.fromValue(left.floatValue()
2689: % right.doubleValue());
2690: case T_byte:
2691: return FloatConstant.fromValue(left.floatValue()
2692: % right.byteValue());
2693: case T_short:
2694: return FloatConstant.fromValue(left.floatValue()
2695: % right.shortValue());
2696: case T_int:
2697: return FloatConstant.fromValue(left.floatValue()
2698: % right.intValue());
2699: case T_long:
2700: return FloatConstant.fromValue(left.floatValue()
2701: % right.longValue());
2702: }
2703: break;
2704: case T_double:
2705: switch (rightId) {
2706: case T_char:
2707: return DoubleConstant.fromValue(left.doubleValue()
2708: % right.charValue());
2709: case T_float:
2710: return DoubleConstant.fromValue(left.doubleValue()
2711: % right.floatValue());
2712: case T_double:
2713: return DoubleConstant.fromValue(left.doubleValue()
2714: % right.doubleValue());
2715: case T_byte:
2716: return DoubleConstant.fromValue(left.doubleValue()
2717: % right.byteValue());
2718: case T_short:
2719: return DoubleConstant.fromValue(left.doubleValue()
2720: % right.shortValue());
2721: case T_int:
2722: return DoubleConstant.fromValue(left.doubleValue()
2723: % right.intValue());
2724: case T_long:
2725: return DoubleConstant.fromValue(left.doubleValue()
2726: % right.longValue());
2727: }
2728: break;
2729: case T_byte:
2730: switch (rightId) {
2731: case T_char:
2732: return IntConstant.fromValue(left.byteValue()
2733: % right.charValue());
2734: case T_float:
2735: return FloatConstant.fromValue(left.byteValue()
2736: % right.floatValue());
2737: case T_double:
2738: return DoubleConstant.fromValue(left.byteValue()
2739: % right.doubleValue());
2740: case T_byte:
2741: return IntConstant.fromValue(left.byteValue()
2742: % right.byteValue());
2743: case T_short:
2744: return IntConstant.fromValue(left.byteValue()
2745: % right.shortValue());
2746: case T_int:
2747: return IntConstant.fromValue(left.byteValue()
2748: % right.intValue());
2749: case T_long:
2750: return LongConstant.fromValue(left.byteValue()
2751: % right.longValue());
2752: }
2753: break;
2754: case T_short:
2755: switch (rightId) {
2756: case T_char:
2757: return IntConstant.fromValue(left.shortValue()
2758: % right.charValue());
2759: case T_float:
2760: return FloatConstant.fromValue(left.shortValue()
2761: % right.floatValue());
2762: case T_double:
2763: return DoubleConstant.fromValue(left.shortValue()
2764: % right.doubleValue());
2765: case T_byte:
2766: return IntConstant.fromValue(left.shortValue()
2767: % right.byteValue());
2768: case T_short:
2769: return IntConstant.fromValue(left.shortValue()
2770: % right.shortValue());
2771: case T_int:
2772: return IntConstant.fromValue(left.shortValue()
2773: % right.intValue());
2774: case T_long:
2775: return LongConstant.fromValue(left.shortValue()
2776: % right.longValue());
2777: }
2778: break;
2779: case T_int:
2780: switch (rightId) {
2781: case T_char:
2782: return IntConstant.fromValue(left.intValue()
2783: % right.charValue());
2784: case T_float:
2785: return FloatConstant.fromValue(left.intValue()
2786: % right.floatValue());
2787: case T_double:
2788: return DoubleConstant.fromValue(left.intValue()
2789: % right.doubleValue());
2790: case T_byte:
2791: return IntConstant.fromValue(left.intValue()
2792: % right.byteValue());
2793: case T_short:
2794: return IntConstant.fromValue(left.intValue()
2795: % right.shortValue());
2796: case T_int:
2797: return IntConstant.fromValue(left.intValue()
2798: % right.intValue());
2799: case T_long:
2800: return LongConstant.fromValue(left.intValue()
2801: % right.longValue());
2802: }
2803: break;
2804: case T_long:
2805: switch (rightId) {
2806: case T_char:
2807: return LongConstant.fromValue(left.longValue()
2808: % right.charValue());
2809: case T_float:
2810: return FloatConstant.fromValue(left.longValue()
2811: % right.floatValue());
2812: case T_double:
2813: return DoubleConstant.fromValue(left.longValue()
2814: % right.doubleValue());
2815: case T_byte:
2816: return LongConstant.fromValue(left.longValue()
2817: % right.byteValue());
2818: case T_short:
2819: return LongConstant.fromValue(left.longValue()
2820: % right.shortValue());
2821: case T_int:
2822: return LongConstant.fromValue(left.longValue()
2823: % right.intValue());
2824: case T_long:
2825: return LongConstant.fromValue(left.longValue()
2826: % right.longValue());
2827: }
2828:
2829: }
2830:
2831: return NotAConstant;
2832: }
2833:
2834: public static final Constant computeConstantOperationRIGHT_SHIFT(
2835: Constant left, int leftId, Constant right, int rightId) {
2836:
2837: switch (leftId) {
2838: case T_char:
2839: switch (rightId) {
2840: case T_char:
2841: return IntConstant.fromValue(left.charValue() >> right
2842: .charValue());
2843: case T_byte:
2844: return IntConstant.fromValue(left.charValue() >> right
2845: .byteValue());
2846: case T_short:
2847: return IntConstant.fromValue(left.charValue() >> right
2848: .shortValue());
2849: case T_int:
2850: return IntConstant.fromValue(left.charValue() >> right
2851: .intValue());
2852: case T_long:
2853: return IntConstant.fromValue(left.charValue() >> right
2854: .longValue());
2855: }
2856: break;
2857: case T_byte:
2858: switch (rightId) {
2859: case T_char:
2860: return IntConstant.fromValue(left.byteValue() >> right
2861: .charValue());
2862: case T_byte:
2863: return IntConstant.fromValue(left.byteValue() >> right
2864: .byteValue());
2865: case T_short:
2866: return IntConstant.fromValue(left.byteValue() >> right
2867: .shortValue());
2868: case T_int:
2869: return IntConstant.fromValue(left.byteValue() >> right
2870: .intValue());
2871: case T_long:
2872: return IntConstant.fromValue(left.byteValue() >> right
2873: .longValue());
2874: }
2875: break;
2876: case T_short:
2877: switch (rightId) {
2878: case T_char:
2879: return IntConstant.fromValue(left.shortValue() >> right
2880: .charValue());
2881: case T_byte:
2882: return IntConstant.fromValue(left.shortValue() >> right
2883: .byteValue());
2884: case T_short:
2885: return IntConstant.fromValue(left.shortValue() >> right
2886: .shortValue());
2887: case T_int:
2888: return IntConstant.fromValue(left.shortValue() >> right
2889: .intValue());
2890: case T_long:
2891: return IntConstant.fromValue(left.shortValue() >> right
2892: .longValue());
2893: }
2894: break;
2895: case T_int:
2896: switch (rightId) {
2897: case T_char:
2898: return IntConstant.fromValue(left.intValue() >> right
2899: .charValue());
2900: case T_byte:
2901: return IntConstant.fromValue(left.intValue() >> right
2902: .byteValue());
2903: case T_short:
2904: return IntConstant.fromValue(left.intValue() >> right
2905: .shortValue());
2906: case T_int:
2907: return IntConstant.fromValue(left.intValue() >> right
2908: .intValue());
2909: case T_long:
2910: return IntConstant.fromValue(left.intValue() >> right
2911: .longValue());
2912: }
2913: break;
2914: case T_long:
2915: switch (rightId) {
2916: case T_char:
2917: return LongConstant.fromValue(left.longValue() >> right
2918: .charValue());
2919: case T_byte:
2920: return LongConstant.fromValue(left.longValue() >> right
2921: .byteValue());
2922: case T_short:
2923: return LongConstant.fromValue(left.longValue() >> right
2924: .shortValue());
2925: case T_int:
2926: return LongConstant.fromValue(left.longValue() >> right
2927: .intValue());
2928: case T_long:
2929: return LongConstant.fromValue(left.longValue() >> right
2930: .longValue());
2931: }
2932:
2933: }
2934:
2935: return NotAConstant;
2936: }
2937:
2938: public static final Constant computeConstantOperationUNSIGNED_RIGHT_SHIFT(
2939: Constant left, int leftId, Constant right, int rightId) {
2940:
2941: switch (leftId) {
2942: case T_char:
2943: switch (rightId) {
2944: case T_char:
2945: return IntConstant.fromValue(left.charValue() >>> right
2946: .charValue());
2947: case T_byte:
2948: return IntConstant.fromValue(left.charValue() >>> right
2949: .byteValue());
2950: case T_short:
2951: return IntConstant.fromValue(left.charValue() >>> right
2952: .shortValue());
2953: case T_int:
2954: return IntConstant.fromValue(left.charValue() >>> right
2955: .intValue());
2956: case T_long:
2957: return IntConstant.fromValue(left.charValue() >>> right
2958: .longValue());
2959: }
2960: break;
2961: case T_byte:
2962: switch (rightId) {
2963: case T_char:
2964: return IntConstant.fromValue(left.byteValue() >>> right
2965: .charValue());
2966: case T_byte:
2967: return IntConstant.fromValue(left.byteValue() >>> right
2968: .byteValue());
2969: case T_short:
2970: return IntConstant.fromValue(left.byteValue() >>> right
2971: .shortValue());
2972: case T_int:
2973: return IntConstant.fromValue(left.byteValue() >>> right
2974: .intValue());
2975: case T_long:
2976: return IntConstant.fromValue(left.byteValue() >>> right
2977: .longValue());
2978: }
2979: break;
2980: case T_short:
2981: switch (rightId) {
2982: case T_char:
2983: return IntConstant
2984: .fromValue(left.shortValue() >>> right
2985: .charValue());
2986: case T_byte:
2987: return IntConstant
2988: .fromValue(left.shortValue() >>> right
2989: .byteValue());
2990: case T_short:
2991: return IntConstant
2992: .fromValue(left.shortValue() >>> right
2993: .shortValue());
2994: case T_int:
2995: return IntConstant
2996: .fromValue(left.shortValue() >>> right
2997: .intValue());
2998: case T_long:
2999: return IntConstant
3000: .fromValue(left.shortValue() >>> right
3001: .longValue());
3002: }
3003: break;
3004: case T_int:
3005: switch (rightId) {
3006: case T_char:
3007: return IntConstant.fromValue(left.intValue() >>> right
3008: .charValue());
3009: case T_byte:
3010: return IntConstant.fromValue(left.intValue() >>> right
3011: .byteValue());
3012: case T_short:
3013: return IntConstant.fromValue(left.intValue() >>> right
3014: .shortValue());
3015: case T_int:
3016: return IntConstant.fromValue(left.intValue() >>> right
3017: .intValue());
3018: case T_long:
3019: return IntConstant.fromValue(left.intValue() >>> right
3020: .longValue());
3021: }
3022: break;
3023: case T_long:
3024: switch (rightId) {
3025: case T_char:
3026: return LongConstant
3027: .fromValue(left.longValue() >>> right
3028: .charValue());
3029: case T_byte:
3030: return LongConstant
3031: .fromValue(left.longValue() >>> right
3032: .byteValue());
3033: case T_short:
3034: return LongConstant
3035: .fromValue(left.longValue() >>> right
3036: .shortValue());
3037: case T_int:
3038: return LongConstant
3039: .fromValue(left.longValue() >>> right
3040: .intValue());
3041: case T_long:
3042: return LongConstant
3043: .fromValue(left.longValue() >>> right
3044: .longValue());
3045: }
3046:
3047: }
3048:
3049: return NotAConstant;
3050: }
3051:
3052: public static final Constant computeConstantOperationXOR(
3053: Constant left, int leftId, Constant right, int rightId) {
3054:
3055: switch (leftId) {
3056: case T_boolean:
3057: return BooleanConstant.fromValue(left.booleanValue()
3058: ^ right.booleanValue());
3059: case T_char:
3060: switch (rightId) {
3061: case T_char:
3062: return IntConstant.fromValue(left.charValue()
3063: ^ right.charValue());
3064: case T_byte:
3065: return IntConstant.fromValue(left.charValue()
3066: ^ right.byteValue());
3067: case T_short:
3068: return IntConstant.fromValue(left.charValue()
3069: ^ right.shortValue());
3070: case T_int:
3071: return IntConstant.fromValue(left.charValue()
3072: ^ right.intValue());
3073: case T_long:
3074: return LongConstant.fromValue(left.charValue()
3075: ^ right.longValue());
3076: }
3077: break;
3078: case T_byte:
3079: switch (rightId) {
3080: case T_char:
3081: return IntConstant.fromValue(left.byteValue()
3082: ^ right.charValue());
3083: case T_byte:
3084: return IntConstant.fromValue(left.byteValue()
3085: ^ right.byteValue());
3086: case T_short:
3087: return IntConstant.fromValue(left.byteValue()
3088: ^ right.shortValue());
3089: case T_int:
3090: return IntConstant.fromValue(left.byteValue()
3091: ^ right.intValue());
3092: case T_long:
3093: return LongConstant.fromValue(left.byteValue()
3094: ^ right.longValue());
3095: }
3096: break;
3097: case T_short:
3098: switch (rightId) {
3099: case T_char:
3100: return IntConstant.fromValue(left.shortValue()
3101: ^ right.charValue());
3102: case T_byte:
3103: return IntConstant.fromValue(left.shortValue()
3104: ^ right.byteValue());
3105: case T_short:
3106: return IntConstant.fromValue(left.shortValue()
3107: ^ right.shortValue());
3108: case T_int:
3109: return IntConstant.fromValue(left.shortValue()
3110: ^ right.intValue());
3111: case T_long:
3112: return LongConstant.fromValue(left.shortValue()
3113: ^ right.longValue());
3114: }
3115: break;
3116: case T_int:
3117: switch (rightId) {
3118: case T_char:
3119: return IntConstant.fromValue(left.intValue()
3120: ^ right.charValue());
3121: case T_byte:
3122: return IntConstant.fromValue(left.intValue()
3123: ^ right.byteValue());
3124: case T_short:
3125: return IntConstant.fromValue(left.intValue()
3126: ^ right.shortValue());
3127: case T_int:
3128: return IntConstant.fromValue(left.intValue()
3129: ^ right.intValue());
3130: case T_long:
3131: return LongConstant.fromValue(left.intValue()
3132: ^ right.longValue());
3133: }
3134: break;
3135: case T_long:
3136: switch (rightId) {
3137: case T_char:
3138: return LongConstant.fromValue(left.longValue()
3139: ^ right.charValue());
3140: case T_byte:
3141: return LongConstant.fromValue(left.longValue()
3142: ^ right.byteValue());
3143: case T_short:
3144: return LongConstant.fromValue(left.longValue()
3145: ^ right.shortValue());
3146: case T_int:
3147: return LongConstant.fromValue(left.longValue()
3148: ^ right.intValue());
3149: case T_long:
3150: return LongConstant.fromValue(left.longValue()
3151: ^ right.longValue());
3152: }
3153: }
3154:
3155: return NotAConstant;
3156: }
3157:
3158: public double doubleValue() {
3159:
3160: throw new ShouldNotImplement(Messages.bind(
3161: Messages.constant_cannotCastedInto, new String[] {
3162: typeName(), "double" })); //$NON-NLS-1$
3163: }
3164:
3165: public float floatValue() {
3166:
3167: throw new ShouldNotImplement(Messages.bind(
3168: Messages.constant_cannotCastedInto, new String[] {
3169: typeName(), "float" })); //$NON-NLS-1$
3170: }
3171:
3172: /**
3173: * Returns true if both constants have the same type and the same actual value
3174: * @param otherConstant
3175: */
3176: public boolean hasSameValue(Constant otherConstant) {
3177: if (this == otherConstant)
3178: return true;
3179: int typeID;
3180: if ((typeID = typeID()) != otherConstant.typeID())
3181: return false;
3182: switch (typeID) {
3183: case TypeIds.T_boolean:
3184: return booleanValue() == otherConstant.booleanValue();
3185: case TypeIds.T_byte:
3186: return byteValue() == otherConstant.byteValue();
3187: case TypeIds.T_char:
3188: return charValue() == otherConstant.charValue();
3189: case TypeIds.T_double:
3190: return doubleValue() == otherConstant.doubleValue();
3191: case TypeIds.T_float:
3192: return floatValue() == otherConstant.floatValue();
3193: case TypeIds.T_int:
3194: return intValue() == otherConstant.intValue();
3195: case TypeIds.T_short:
3196: return shortValue() == otherConstant.shortValue();
3197: case TypeIds.T_long:
3198: return longValue() == otherConstant.longValue();
3199: case TypeIds.T_JavaLangString:
3200: String value = stringValue();
3201: return value == null ? otherConstant.stringValue() == null
3202: : value.equals(otherConstant.stringValue());
3203: }
3204: return false;
3205: }
3206:
3207: public int intValue() {
3208:
3209: throw new ShouldNotImplement(Messages.bind(
3210: Messages.constant_cannotCastedInto, new String[] {
3211: typeName(), "int" })); //$NON-NLS-1$
3212: }
3213:
3214: public long longValue() {
3215:
3216: throw new ShouldNotImplement(Messages.bind(
3217: Messages.constant_cannotCastedInto, new String[] {
3218: typeName(), "long" })); //$NON-NLS-1$
3219: }
3220:
3221: public short shortValue() {
3222:
3223: throw new ShouldNotImplement(Messages.bind(
3224: Messages.constant_cannotConvertedTo, new String[] {
3225: typeName(), "short" })); //$NON-NLS-1$
3226: }
3227:
3228: public String stringValue() {
3229:
3230: throw new ShouldNotImplement(Messages.bind(
3231: Messages.constant_cannotConvertedTo, new String[] {
3232: typeName(), "String" })); //$NON-NLS-1$
3233: }
3234:
3235: public String toString() {
3236:
3237: if (this == NotAConstant)
3238: return "(Constant) NotAConstant"; //$NON-NLS-1$
3239: return super .toString();
3240: }
3241:
3242: public abstract int typeID();
3243:
3244: public String typeName() {
3245: switch (typeID()) {
3246: case T_int:
3247: return "int"; //$NON-NLS-1$
3248: case T_byte:
3249: return "byte"; //$NON-NLS-1$
3250: case T_short:
3251: return "short"; //$NON-NLS-1$
3252: case T_char:
3253: return "char"; //$NON-NLS-1$
3254: case T_float:
3255: return "float"; //$NON-NLS-1$
3256: case T_double:
3257: return "double"; //$NON-NLS-1$
3258: case T_boolean:
3259: return "boolean"; //$NON-NLS-1$
3260: case T_long:
3261: return "long";//$NON-NLS-1$
3262: case T_JavaLangString:
3263: return "java.lang.String"; //$NON-NLS-1$
3264: case T_null:
3265: return "null"; //$NON-NLS-1$
3266: default:
3267: return "unknown"; //$NON-NLS-1$
3268: }
3269: }
3270: }
|