net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/impl/Constant.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  ******************************************************************************/
  11 package net.sourceforge.phpdt.internal.compiler.impl;
  12
  13 import net.sourceforge.phpdt.internal.compiler.ast.OperatorIds;
  14 import net.sourceforge.phpdt.internal.compiler.lookup.TypeIds;
  15 import net.sourceforge.phpdt.internal.compiler.problem.ShouldNotImplement;
  16 import net.sourceforge.phpdt.internal.compiler.util.Util;
  17
  18 public abstract class Constant implements TypeIds, OperatorIds {
  19         public static final Constant NotAConstant = new DoubleConstant(Double.NaN);
  20
  21         public static final IntConstant Zero = new IntConstant(0);
  22         public static final IntConstant Two = new IntConstant(2);
  23         public static final IntConstant One = new IntConstant(1);
  24 public boolean booleanValue() {
  25         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"boolean")); //$NON-NLS-1$ //$NON-NLS-2$
  26 }
  27 public byte byteValue() {
  28         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"byte")); //$NON-NLS-1$ //$NON-NLS-2$
  29 }
  30 public final Constant castTo(int conversionToTargetType){
  31         //the cast is an int of the form
  32         // (castId<<4)+typeId (in order to follow the
  33         //user written style (cast)expression ....
  34         //This method assumes that the TC is done (correctly :-)
  35
  36         if (this == NotAConstant) return NotAConstant ;
  37         switch(conversionToTargetType){
  38                 case T_undefined :                                              return this;
  39 //          case (T_undefined<<4)+T_undefined    : return NotAConstant ;
  40 //          case (T_undefined<<4)+T_byte                 : return NotAConstant ;
  41 //          case (T_undefined<<4)+T_long                 : return NotAConstant ;
  42 //          case (T_undefined<<4)+T_short                : return NotAConstant ;
  43 //          case (T_undefined<<4)+T_void                 : return NotAConstant ;
  44 //          case (T_undefined<<4)+T_String       : return NotAConstant ;
  45 //          case (T_undefined<<4)+T_Object       : return NotAConstant ;
  46 //          case (T_undefined<<4)+T_double       : return NotAConstant ;
  47 //          case (T_undefined<<4)+T_float                : return NotAConstant ;
  48 //          case (T_undefined<<4)+T_boolean      : return NotAConstant ;
  49 //          case (T_undefined<<4)+T_char                 : return NotAConstant ;
  50 //          case (T_undefined<<4)+T_int                  : return NotAConstant ;
  51 //          case (T_undefined<<4)+T_null                 : return NotAConstant ;
  52
  53 //          case (T_byte<<4)+T_undefined         : return NotAConstant ;
  54             case (T_byte<<4)+T_byte              : return this ;
  55             case (T_byte<<4)+T_long              : return Constant.fromValue((byte)this.longValue()) ;
  56             case (T_byte<<4)+T_short             : return Constant.fromValue((byte)this.shortValue());
  57 //          case (T_byte<<4)+T_void              : return NotAConstant ;
  58 //          case (T_byte<<4)+T_String            : return NotAConstant ;
  59 //          case (T_byte<<4)+T_Object            : return NotAConstant ;
  60             case (T_byte<<4)+T_double            : return Constant.fromValue((byte)this.doubleValue());
  61             case (T_byte<<4)+T_float             : return Constant.fromValue((byte)this.floatValue());
  62 //          case (T_byte<<4)+T_boolean           : return NotAConstant ;
  63             case (T_byte<<4)+T_char              : return Constant.fromValue((byte)this.charValue());
  64             case (T_byte<<4)+T_int               : return Constant.fromValue((byte)this.intValue());
  65 //          case (T_byte<<4)+T_null              : return NotAConstant ;
  66
  67 //          case (T_long<<4)+T_undefined         : return NotAConstant ;
  68             case (T_long<<4)+T_byte              : return Constant.fromValue((long)this.byteValue());
  69             case (T_long<<4)+T_long              : return this ;
  70             case (T_long<<4)+T_short             : return Constant.fromValue((long)this.shortValue());
  71 //          case (T_long<<4)+T_void              : return NotAConstant ;
  72 //          case (T_long<<4)+T_String            : return NotAConstant ;
  73 //          case (T_long<<4)+T_Object            : return NotAConstant ;
  74             case (T_long<<4)+T_double            : return Constant.fromValue((long)this.doubleValue());
  75             case (T_long<<4)+T_float             : return Constant.fromValue((long)this.floatValue());
  76 //          case (T_long<<4)+T_boolean           : return NotAConstant ;
  77             case (T_long<<4)+T_char              : return Constant.fromValue((long)this.charValue());
  78             case (T_long<<4)+T_int               : return Constant.fromValue((long)this.intValue());
  79 //          case (T_long<<4)+T_null              : return NotAConstant ;
  80
  81 //          case (T_short<<4)+T_undefined        : return NotAConstant ;
  82             case (T_short<<4)+T_byte             : return Constant.fromValue((short)this.byteValue());
  83             case (T_short<<4)+T_long             : return Constant.fromValue((short)this.longValue());
  84             case (T_short<<4)+T_short            : return this ;
  85 //          case (T_short<<4)+T_void             : return NotAConstant ;
  86 //          case (T_short<<4)+T_String           : return NotAConstant ;
  87 //          case (T_short<<4)+T_Object           : return NotAConstant ;
  88             case (T_short<<4)+T_double           : return Constant.fromValue((short)this.doubleValue()) ;
  89             case (T_short<<4)+T_float            : return Constant.fromValue((short)this.floatValue()) ;
  90 //          case (T_short<<4)+T_boolean          : return NotAConstant ;
  91             case (T_short<<4)+T_char             : return Constant.fromValue((short)this.charValue()) ;
  92             case (T_short<<4)+T_int              : return Constant.fromValue((short)this.intValue()) ;
  93 //          case (T_short<<4)+T_null             : return NotAConstant ;
  94
  95 //          case (T_void<<4)+T_undefined         : return NotAConstant ;
  96 //          case (T_void<<4)+T_byte              : return NotAConstant ;
  97 //          case (T_void<<4)+T_long              : return NotAConstant ;
  98 //          case (T_void<<4)+T_short             : return NotAConstant ;
  99 //          case (T_void<<4)+T_void              : return NotAConstant ;
 100 //          case (T_void<<4)+T_String            : return NotAConstant ;
 101 //          case (T_void<<4)+T_Object            : return NotAConstant ;
 102 //          case (T_void<<4)+T_double            : return NotAConstant ;
 103 //          case (T_void<<4)+T_float             : return NotAConstant ;
 104 //          case (T_void<<4)+T_boolean           : return NotAConstant ;
 105 //          case (T_void<<4)+T_char              : return NotAConstant ;
 106 //          case (T_void<<4)+T_int               : return NotAConstant ;
 107 //          case (T_void<<4)+T_null              : return NotAConstant ;
 108
 109 //          case (T_String<<4)+T_undefined   : return NotAConstant ;
 110 //          case (T_String<<4)+T_byte            : return NotAConstant ;
 111 //          case (T_String<<4)+T_long            : return NotAConstant ;
 112 //          case (T_String<<4)+T_short           : return NotAConstant ;
 113 //          case (T_String<<4)+T_void            : return NotAConstant ;
 114             case (T_String<<4)+T_String          : return this ;
 115 //          case (T_String<<4)+T_Object          : return NotAConstant ;
 116 //          case (T_String<<4)+T_double          : return NotAConstant ;
 117 //          case (T_String<<4)+T_float           : return NotAConstant ;
 118 //          case (T_String<<4)+T_boolean         : return NotAConstant ;
 119 //          case (T_String<<4)+T_char            : return NotAConstant ;
 120 //          case (T_String<<4)+T_int             : return NotAConstant ;
 121 //          case (T_String<<4)+T_null            : return NotAConstant ;
 122
 123 //          case (T_Object<<4)+T_undefined      : return NotAConstant ;
 124 //          case (T_Object<<4)+T_byte                   : return NotAConstant ;
 125 //          case (T_Object<<4)+T_long                   : return NotAConstant ;
 126 //          case (T_Object<<4)+T_short                  : return NotAConstant ;
 127 //          case (T_Object<<4)+T_void                   : return NotAConstant ;
 128 //          case (T_Object<<4)+T_String                 : return NotAConstant ;
 129 //          case (T_Object<<4)+T_Object                 : return NotAConstant ;
 130 //          case (T_Object<<4)+T_double                 : return NotAConstant ;
 131 //          case (T_Object<<4)+T_float                  : return NotAConstant ;
 132 //          case (T_Object<<4)+T_boolean                : return NotAConstant ;
 133 //          case (T_Object<<4)+T_char                   : return NotAConstant ;
 134 //          case (T_Object<<4)+T_int                    : return NotAConstant ;
 135             case (T_Object<<4)+T_null                   : return this ;
 136
 137 //          case (T_double<<4)+T_undefined      : return NotAConstant ;
 138             case (T_double<<4)+T_byte                   : return Constant.fromValue((double)this.byteValue()) ;
 139             case (T_double<<4)+T_long                   : return Constant.fromValue((double)this.longValue()) ;
 140             case (T_double<<4)+T_short                  : return Constant.fromValue((double)this.shortValue()) ;
 141 //          case (T_double<<4)+T_void                   : return NotAConstant ;
 142 //          case (T_double<<4)+T_String                 : return NotAConstant ;
 143 //          case (T_double<<4)+T_Object                 : return NotAConstant ;
 144             case (T_double<<4)+T_double                 : return this ;
 145             case (T_double<<4)+T_float                  : return Constant.fromValue((double)this.floatValue()) ;
 146 //          case (T_double<<4)+T_boolean                : return NotAConstant ;
 147             case (T_double<<4)+T_char                   : return Constant.fromValue((double)this.charValue()) ;
 148             case (T_double<<4)+T_int                    : return Constant.fromValue((double)this.intValue());
 149 //          case (T_double<<4)+T_null                   : return NotAConstant ;
 150
 151 //          case (T_float<<4)+T_undefined        : return NotAConstant ;
 152             case (T_float<<4)+T_byte             : return Constant.fromValue((float)this.byteValue()) ;
 153             case (T_float<<4)+T_long             : return Constant.fromValue((float)this.longValue())  ;
 154             case (T_float<<4)+T_short            : return Constant.fromValue((float)this.shortValue())  ;
 155 //          case (T_float<<4)+T_void             : return NotAConstant ;
 156 //          case (T_float<<4)+T_String           : return NotAConstant ;
 157 //          case (T_float<<4)+T_Object           : return NotAConstant ;
 158             case (T_float<<4)+T_double           : return Constant.fromValue((float)this.doubleValue())  ;
 159             case (T_float<<4)+T_float            : return this ;
 160 //          case (T_float<<4)+T_boolean          : return NotAConstant ;
 161             case (T_float<<4)+T_char             : return Constant.fromValue((float)this.charValue())  ;
 162             case (T_float<<4)+T_int              : return Constant.fromValue((float)this.intValue())  ;
 163 //          case (T_float<<4)+T_null             : return NotAConstant ;
 164
 165 //          case (T_boolean<<4)+T_undefined              : return NotAConstant ;
 166 //          case (T_boolean<<4)+T_byte                           : return NotAConstant ;
 167 //          case (T_boolean<<4)+T_long                           : return NotAConstant ;
 168 //          case (T_boolean<<4)+T_short                          : return NotAConstant ;
 169 //          case (T_boolean<<4)+T_void                           : return NotAConstant ;
 170 //          case (T_boolean<<4)+T_String                         : return NotAConstant ;
 171 //          case (T_boolean<<4)+T_Object                         : return NotAConstant ;
 172 //          case (T_boolean<<4)+T_double                         : return NotAConstant ;
 173 //          case (T_boolean<<4)+T_float                          : return NotAConstant ;
 174             case (T_boolean<<4)+T_boolean                        : return this ;
 175 //          case (T_boolean<<4)+T_char                           : return NotAConstant ;
 176 //          case (T_boolean<<4)+T_int                            : return NotAConstant ;
 177 //          case (T_boolean<<4)+T_null                           : return NotAConstant ;
 178
 179 //          case (T_char<<4)+T_undefined         : return NotAConstant ;
 180             case (T_char<<4)+T_byte              : return Constant.fromValue((char)this.byteValue())  ;
 181             case (T_char<<4)+T_long              : return Constant.fromValue((char)this.longValue())  ;
 182             case (T_char<<4)+T_short             : return Constant.fromValue((char)this.shortValue()) ;
 183 //          case (T_char<<4)+T_void              : return NotAConstant ;
 184 //          case (T_char<<4)+T_String            : return NotAConstant ;
 185 //          case (T_char<<4)+T_Object            : return NotAConstant ;
 186             case (T_char<<4)+T_double            : return Constant.fromValue((char)this.doubleValue()) ;
 187             case (T_char<<4)+T_float             : return Constant.fromValue((char)this.floatValue()) ;
 188 //          case (T_char<<4)+T_boolean           : return NotAConstant ;
 189             case (T_char<<4)+T_char              : return this ;
 190             case (T_char<<4)+T_int               : return Constant.fromValue((char)this.intValue()) ;
 191 //          case (T_char<<4)+T_null              : return NotAConstant ;
 192
 193 //          case (T_int<<4)+T_undefined          : return NotAConstant ;
 194             case (T_int<<4)+T_byte               : return Constant.fromValue((int)this.byteValue()) ;
 195             case (T_int<<4)+T_long               : return Constant.fromValue((int)this.longValue())  ;
 196             case (T_int<<4)+T_short              : return Constant.fromValue((int)this.shortValue())  ;
 197 //          case (T_int<<4)+T_void               : return NotAConstant ;
 198 //          case (T_int<<4)+T_String             : return NotAConstant ;
 199 //          case (T_int<<4)+T_Object             : return NotAConstant ;
 200             case (T_int<<4)+T_double             : return Constant.fromValue((int)this.doubleValue())  ;
 201             case (T_int<<4)+T_float              : return Constant.fromValue((int)this.floatValue())  ;
 202 //          case (T_int<<4)+T_boolean            : return NotAConstant ;
 203             case (T_int<<4)+T_char               : return Constant.fromValue((int)this.charValue()) ;
 204             case (T_int<<4)+T_int                        : return this ;
 205 //          case (T_int<<4)+T_null               : return NotAConstant ;
 206
 207 //          case (T_null<<4)+T_undefined                 : return NotAConstant ;
 208 //          case (T_null<<4)+T_byte                      : return NotAConstant ;
 209 //          case (T_null<<4)+T_long                      : return NotAConstant ;
 210 //          case (T_null<<4)+T_short                     : return NotAConstant ;
 211 //          case (T_null<<4)+T_void                      : return NotAConstant ;
 212 //          case (T_null<<4)+T_String                    : return NotAConstant ;
 213 //          case (T_null<<4)+T_Object                    : return NotAConstant ;
 214 //          case (T_null<<4)+T_double                    : return NotAConstant ;
 215 //          case (T_null<<4)+T_float                     : return NotAConstant ;
 216 //          case (T_null<<4)+T_boolean                   : return NotAConstant ;
 217 //          case (T_null<<4)+T_char                      : return NotAConstant ;
 218 //          case (T_null<<4)+T_int                       : return NotAConstant ;
 219             case (T_null<<4)+T_null                      : return this ;
 220         }
 221
 222
 223
 224         return NotAConstant ;
 225 }
 226 public char charValue() {
 227         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"char")); //$NON-NLS-1$ //$NON-NLS-2$
 228 }
 229 public static final Constant computeConstantOperation(Constant cst, int id, int operator) {
 230         //this method  assumes that the TC has been done .
 231         //the result should be availbale with not runtime error
 232
 233         switch (operator) {
 234                 case NOT        :
 235                                                 return Constant.fromValue(!cst.booleanValue());
 236                 case PLUS       :       return cst ;
 237                 case MINUS      :       //the two special -9223372036854775808L and -2147483648 are inlined at parseTime
 238                                                 switch (id){
 239                                                         case T_float  : float f ;
 240                                                                                         if ( (f= cst.floatValue()) == 0.0f)
 241                                                                                         { //positive and negative 0....
 242                                                                                                 if (Float.floatToIntBits(f) == 0)
 243                                                                                                         return Constant.fromValue(-0.0f);
 244                                                                                                 else
 245                                                                                                         return Constant.fromValue(0.0f);}
 246                                                                                         break; //default case
 247                                                         case T_double : double d ;
 248                                                                                         if ( (d= cst.doubleValue()) == 0.0d)
 249                                                                                         { //positive and negative 0....
 250                                                                                                 if (Double.doubleToLongBits(d) == 0)
 251                                                                                                         return Constant.fromValue(-0.0d);
 252                                                                                                 else
 253                                                                                                         return Constant.fromValue(0.0d);}
 254                                                                                         break; //default case
 255                                                 }
 256                                                 return computeConstantOperationMINUS(Zero,T_int,operator,cst,id);
 257                 case TWIDDLE:
 258                         switch (id){
 259                                 case T_char :   return Constant.fromValue(~ cst.charValue()) ;
 260                                 case T_byte:    return Constant.fromValue(~ cst.byteValue()) ;
 261                                 case T_short:   return Constant.fromValue(~ cst.shortValue()) ;
 262                                 case T_int:             return Constant.fromValue(~ cst.intValue()) ;
 263                                 case T_long:    return Constant.fromValue(~ cst.longValue()) ;
 264                                 default : return NotAConstant;} //should not occur.....(conservative code)
 265                 default : return NotAConstant ;}} //should not occur....(conservative code)
 266 public static final Constant computeConstantOperation(Constant left, int leftId, int operator, Constant right, int rightId) {
 267         //this method  assumes that the TC has been done . So (except for divide by zero)
 268         //the result should be availbale with not runtime error
 269
 270         switch (operator) {
 271                 case AND                : return computeConstantOperationAND            (left,leftId,operator,right,rightId) ;
 272                 case AND_AND    : return computeConstantOperationAND_AND        (left,leftId,operator,right,rightId) ;
 273                 case DIVIDE     : return computeConstantOperationDIVIDE         (left,leftId,operator,right,rightId) ;
 274                 case GREATER    : return computeConstantOperationGREATER        (left,leftId,operator,right,rightId) ;
 275                 case GREATER_EQUAL      : return computeConstantOperationGREATER_EQUAL(left,leftId,operator,right,rightId) ;
 276                 case LEFT_SHIFT : return computeConstantOperationLEFT_SHIFT     (left,leftId,operator,right,rightId) ;
 277                 case LESS               : return computeConstantOperationLESS           (left,leftId,operator,right,rightId) ;
 278                 case LESS_EQUAL : return computeConstantOperationLESS_EQUAL     (left,leftId,operator,right,rightId) ;
 279                 case MINUS              : return computeConstantOperationMINUS          (left,leftId,operator,right,rightId) ;
 280                 case MULTIPLY   : return computeConstantOperationMULTIPLY       (left,leftId,operator,right,rightId) ;
 281                 case OR                 : return computeConstantOperationOR                     (left,leftId,operator,right,rightId) ;
 282                 case OR_OR              : return computeConstantOperationOR_OR          (left,leftId,operator,right,rightId) ;
 283                 case PLUS               : return computeConstantOperationPLUS           (left,leftId,operator,right,rightId) ;
 284                 case REMAINDER  : return computeConstantOperationREMAINDER      (left,leftId,operator,right,rightId) ;
 285                 case RIGHT_SHIFT: return computeConstantOperationRIGHT_SHIFT(left,leftId,operator,right,rightId) ;
 286                 case UNSIGNED_RIGHT_SHIFT: return computeConstantOperationUNSIGNED_RIGHT_SHIFT(left,leftId,operator,right,rightId) ;
 287                 case XOR                : return computeConstantOperationXOR            (left,leftId,operator,right,rightId) ;
 288
 289                 default : return NotAConstant ;}} //should not occurs....(conservative code)
 290 public static final Constant computeConstantOperationAND(Constant left, int leftId, int operator, Constant right, int rightId) {
 291         //this method  assumes that the TC has been done .
 292
 293         switch (leftId){
 294                 case T_boolean :                return Constant.fromValue(left.booleanValue() & right.booleanValue()) ;
 295                 case T_char :
 296                         switch (rightId){
 297                                 case T_char :   return Constant.fromValue(left.charValue() & right.charValue()) ;
 298                                 case T_byte:    return Constant.fromValue(left.charValue() & right.byteValue()) ;
 299                                 case T_short:   return Constant.fromValue(left.charValue() & right.shortValue()) ;
 300                                 case T_int:             return Constant.fromValue(left.charValue() & right.intValue()) ;
 301                                 case T_long:    return Constant.fromValue(left.charValue() & right.longValue()) ;}
 302                 break ;
 303                 case T_byte :
 304                         switch (rightId){
 305                                 case T_char :   return Constant.fromValue(left.byteValue() & right.charValue()) ;
 306                                 case T_byte:    return Constant.fromValue(left.byteValue() & right.byteValue()) ;
 307                                 case T_short:   return Constant.fromValue(left.byteValue() & right.shortValue()) ;
 308                                 case T_int:             return Constant.fromValue(left.byteValue() & right.intValue()) ;
 309                                 case T_long:    return Constant.fromValue(left.byteValue() & right.longValue()) ;}
 310                 break;
 311                 case T_short :
 312                         switch (rightId){
 313                                 case T_char :   return Constant.fromValue(left.shortValue() & right.charValue()) ;
 314                                 case T_byte:    return Constant.fromValue(left.shortValue() & right.byteValue()) ;
 315                                 case T_short:   return Constant.fromValue(left.shortValue() & right.shortValue()) ;
 316                                 case T_int:             return Constant.fromValue(left.shortValue() & right.intValue()) ;
 317                                 case T_long:    return Constant.fromValue(left.shortValue() & right.longValue()) ;}
 318                 break;
 319                 case T_int :
 320                         switch (rightId){
 321                                 case T_char :   return Constant.fromValue(left.intValue() & right.charValue()) ;
 322                                 case T_byte:    return Constant.fromValue(left.intValue() & right.byteValue()) ;
 323                                 case T_short:   return Constant.fromValue(left.intValue() & right.shortValue()) ;
 324                                 case T_int:             return Constant.fromValue(left.intValue() & right.intValue()) ;
 325                                 case T_long:    return Constant.fromValue(left.intValue() & right.longValue()) ;}
 326                 break;
 327                 case T_long :
 328                         switch (rightId){
 329                                 case T_char :   return Constant.fromValue(left.longValue() & right.charValue()) ;
 330                                 case T_byte:    return Constant.fromValue(left.longValue() & right.byteValue()) ;
 331                                 case T_short:   return Constant.fromValue(left.longValue() & right.shortValue()) ;
 332                                 case T_int:             return Constant.fromValue(left.longValue() & right.intValue()) ;
 333                                 case T_long:    return Constant.fromValue(left.longValue() & right.longValue()) ;}
 334
 335                 }
 336
 337
 338         return NotAConstant ;}  // should not get here
 339 public static final Constant computeConstantOperationAND_AND(Constant left, int leftId, int operator, Constant right, int rightId) {
 340         //this method  assumes that the TC has been done .
 341
 342         return Constant.fromValue(left.booleanValue() && right.booleanValue()) ;}
 343 public static final Constant computeConstantOperationDIVIDE(Constant left, int leftId, int operator, Constant right, int rightId) {
 344         //this method  assumes that the TC has been done .
 345         // the /0 must be handled outside this method (error reporting)
 346
 347         switch (leftId){
 348                 case T_char :
 349                         switch (rightId){
 350                                 case T_char :   return Constant.fromValue(left.charValue() / right.charValue()) ;
 351                                 case T_float:   return Constant.fromValue(left.charValue() / right.floatValue()) ;
 352                                 case T_double:  return Constant.fromValue(left.charValue() / right.doubleValue()) ;
 353                                 case T_byte:    return Constant.fromValue(left.charValue() / right.byteValue()) ;
 354                                 case T_short:   return Constant.fromValue(left.charValue() / right.shortValue()) ;
 355                                 case T_int:             return Constant.fromValue(left.charValue() / right.intValue()) ;
 356                                 case T_long:    return Constant.fromValue(left.charValue() / right.longValue()) ;}
 357                 break;
 358                 case T_float :
 359                         switch (rightId){
 360                                 case T_char :   return Constant.fromValue(left.floatValue() / right.charValue()) ;
 361                                 case T_float:   return Constant.fromValue(left.floatValue() / right.floatValue()) ;
 362                                 case T_double:  return Constant.fromValue(left.floatValue() / right.doubleValue()) ;
 363                                 case T_byte:    return Constant.fromValue(left.floatValue() / right.byteValue()) ;
 364                                 case T_short:   return Constant.fromValue(left.floatValue() / right.shortValue()) ;
 365                                 case T_int:             return Constant.fromValue(left.floatValue() / right.intValue()) ;
 366                                 case T_long:    return Constant.fromValue(left.floatValue() / right.longValue()) ;}
 367                 break;
 368                 case T_double :
 369                         switch (rightId){
 370                                 case T_char :   return Constant.fromValue(left.doubleValue() / right.charValue()) ;
 371                                 case T_float:   return Constant.fromValue(left.doubleValue() / right.floatValue()) ;
 372                                 case T_double:  return Constant.fromValue(left.doubleValue() / right.doubleValue()) ;
 373                                 case T_byte:    return Constant.fromValue(left.doubleValue() / right.byteValue()) ;
 374                                 case T_short:   return Constant.fromValue(left.doubleValue() / right.shortValue()) ;
 375                                 case T_int:             return Constant.fromValue(left.doubleValue() / right.intValue()) ;
 376                                 case T_long:    return Constant.fromValue(left.doubleValue() / right.longValue()) ;}
 377                 break;
 378                 case T_byte :
 379                         switch (rightId){
 380                                 case T_char :   return Constant.fromValue(left.byteValue() / right.charValue()) ;
 381                                 case T_float:   return Constant.fromValue(left.byteValue() / right.floatValue()) ;
 382                                 case T_double:  return Constant.fromValue(left.byteValue() / right.doubleValue()) ;
 383                                 case T_byte:    return Constant.fromValue(left.byteValue() / right.byteValue()) ;
 384                                 case T_short:   return Constant.fromValue(left.byteValue() / right.shortValue()) ;
 385                                 case T_int:             return Constant.fromValue(left.byteValue() / right.intValue()) ;
 386                                 case T_long:    return Constant.fromValue(left.byteValue() / right.longValue()) ;}
 387                 break;
 388                 case T_short :
 389                         switch (rightId){
 390                                 case T_char :   return Constant.fromValue(left.shortValue() / right.charValue()) ;
 391                                 case T_float:   return Constant.fromValue(left.shortValue() / right.floatValue()) ;
 392                                 case T_double:  return Constant.fromValue(left.shortValue() / right.doubleValue()) ;
 393                                 case T_byte:    return Constant.fromValue(left.shortValue() / right.byteValue()) ;
 394                                 case T_short:   return Constant.fromValue(left.shortValue() / right.shortValue()) ;
 395                                 case T_int:             return Constant.fromValue(left.shortValue() / right.intValue()) ;
 396                                 case T_long:    return Constant.fromValue(left.shortValue() / right.longValue()) ;}
 397                 break;
 398                 case T_int :
 399                         switch (rightId){
 400                                 case T_char :   return Constant.fromValue(left.intValue() / right.charValue()) ;
 401                                 case T_float:   return Constant.fromValue(left.intValue() / right.floatValue()) ;
 402                                 case T_double:  return Constant.fromValue(left.intValue() / right.doubleValue()) ;
 403                                 case T_byte:    return Constant.fromValue(left.intValue() / right.byteValue()) ;
 404                                 case T_short:   return Constant.fromValue(left.intValue() / right.shortValue()) ;
 405                                 case T_int:             return Constant.fromValue(left.intValue() / right.intValue()) ;
 406                                 case T_long:    return Constant.fromValue(left.intValue() / right.longValue()) ;}
 407                 break;
 408                 case T_long :
 409                         switch (rightId){
 410                                 case T_char :   return Constant.fromValue(left.longValue() / right.charValue()) ;
 411                                 case T_float:   return Constant.fromValue(left.longValue() / right.floatValue()) ;
 412                                 case T_double:  return Constant.fromValue(left.longValue() / right.doubleValue()) ;
 413                                 case T_byte:    return Constant.fromValue(left.longValue() / right.byteValue()) ;
 414                                 case T_short:   return Constant.fromValue(left.longValue() / right.shortValue()) ;
 415                                 case T_int:             return Constant.fromValue(left.longValue() / right.intValue()) ;
 416                                 case T_long:    return Constant.fromValue(left.longValue() / right.longValue()) ;}
 417
 418                 }
 419
 420
 421         return NotAConstant ;}  //should not get here
 422 public static final Constant computeConstantOperationEQUAL_EQUAL(Constant left, int leftId, int operator, Constant right, int rightId) {
 423         //this method  assumes that the TC has been done .
 424
 425         switch (leftId){
 426                 case T_boolean :
 427                         if (rightId == T_boolean) {
 428                                 return Constant.fromValue(left.booleanValue() == right.booleanValue()) ;
 429                         }
 430                 break ;
 431                 case T_char :
 432                         switch (rightId){
 433                                 case T_char :   return Constant.fromValue(left.charValue() == right.charValue()) ;
 434                                 case T_float:   return Constant.fromValue(left.charValue() == right.floatValue()) ;
 435                                 case T_double:  return Constant.fromValue(left.charValue() == right.doubleValue()) ;
 436                                 case T_byte:    return Constant.fromValue(left.charValue() == right.byteValue()) ;
 437                                 case T_short:   return Constant.fromValue(left.charValue() == right.shortValue()) ;
 438                                 case T_int:             return Constant.fromValue(left.charValue() == right.intValue()) ;
 439                                 case T_long:    return Constant.fromValue(left.charValue() == right.longValue()) ;}
 440                 break;
 441                 case T_float :
 442                         switch (rightId){
 443                                 case T_char :   return Constant.fromValue(left.floatValue() == right.charValue()) ;
 444                                 case T_float:   return Constant.fromValue(left.floatValue() == right.floatValue()) ;
 445                                 case T_double:  return Constant.fromValue(left.floatValue() == right.doubleValue()) ;
 446                                 case T_byte:    return Constant.fromValue(left.floatValue() == right.byteValue()) ;
 447                                 case T_short:   return Constant.fromValue(left.floatValue() == right.shortValue()) ;
 448                                 case T_int:             return Constant.fromValue(left.floatValue() == right.intValue()) ;
 449                                 case T_long:    return Constant.fromValue(left.floatValue() == right.longValue()) ;}
 450                 break;
 451                 case T_double :
 452                         switch (rightId){
 453                                 case T_char :   return Constant.fromValue(left.doubleValue() == right.charValue()) ;
 454                                 case T_float:   return Constant.fromValue(left.doubleValue() == right.floatValue()) ;
 455                                 case T_double:  return Constant.fromValue(left.doubleValue() == right.doubleValue()) ;
 456                                 case T_byte:    return Constant.fromValue(left.doubleValue() == right.byteValue()) ;
 457                                 case T_short:   return Constant.fromValue(left.doubleValue() == right.shortValue()) ;
 458                                 case T_int:             return Constant.fromValue(left.doubleValue() == right.intValue()) ;
 459                                 case T_long:    return Constant.fromValue(left.doubleValue() == right.longValue()) ;}
 460                 break;
 461                 case T_byte :
 462                         switch (rightId){
 463                                 case T_char :   return Constant.fromValue(left.byteValue() == right.charValue()) ;
 464                                 case T_float:   return Constant.fromValue(left.byteValue() == right.floatValue()) ;
 465                                 case T_double:  return Constant.fromValue(left.byteValue() == right.doubleValue()) ;
 466                                 case T_byte:    return Constant.fromValue(left.byteValue() == right.byteValue()) ;
 467                                 case T_short:   return Constant.fromValue(left.byteValue() == right.shortValue()) ;
 468                                 case T_int:             return Constant.fromValue(left.byteValue() == right.intValue()) ;
 469                                 case T_long:    return Constant.fromValue(left.byteValue() == right.longValue()) ;}
 470                 break;
 471                 case T_short :
 472                         switch (rightId){
 473                                 case T_char :   return Constant.fromValue(left.shortValue() == right.charValue()) ;
 474                                 case T_float:   return Constant.fromValue(left.shortValue() == right.floatValue()) ;
 475                                 case T_double:  return Constant.fromValue(left.shortValue() == right.doubleValue()) ;
 476                                 case T_byte:    return Constant.fromValue(left.shortValue() == right.byteValue()) ;
 477                                 case T_short:   return Constant.fromValue(left.shortValue() == right.shortValue()) ;
 478                                 case T_int:             return Constant.fromValue(left.shortValue() == right.intValue()) ;
 479                                 case T_long:    return Constant.fromValue(left.shortValue() == right.longValue()) ;}
 480                 break;
 481                 case T_int :
 482                         switch (rightId){
 483                                 case T_char :   return Constant.fromValue(left.intValue() == right.charValue()) ;
 484                                 case T_float:   return Constant.fromValue(left.intValue() == right.floatValue()) ;
 485                                 case T_double:  return Constant.fromValue(left.intValue() == right.doubleValue()) ;
 486                                 case T_byte:    return Constant.fromValue(left.intValue() == right.byteValue()) ;
 487                                 case T_short:   return Constant.fromValue(left.intValue() == right.shortValue()) ;
 488                                 case T_int:             return Constant.fromValue(left.intValue() == right.intValue()) ;
 489                                 case T_long:    return Constant.fromValue(left.intValue() == right.longValue()) ;}
 490                 break;
 491                 case T_long :
 492                         switch (rightId){
 493                                 case T_char :   return Constant.fromValue(left.longValue() == right.charValue()) ;
 494                                 case T_float:   return Constant.fromValue(left.longValue() == right.floatValue()) ;
 495                                 case T_double:  return Constant.fromValue(left.longValue() == right.doubleValue()) ;
 496                                 case T_byte:    return Constant.fromValue(left.longValue() == right.byteValue()) ;
 497                                 case T_short:   return Constant.fromValue(left.longValue() == right.shortValue()) ;
 498                                 case T_int:             return Constant.fromValue(left.longValue() == right.intValue()) ;
 499                                 case T_long:    return Constant.fromValue(left.longValue() == right.longValue()) ;}
 500                 break;
 501                 case T_String :
 502                         if (rightId == T_String) {
 503                                 //String are intermed in th compiler==>thus if two string constant
 504                                 //get to be compared, it is an equal on the vale which is done
 505                                 return Constant.fromValue(((StringConstant)left).compileTimeEqual((StringConstant)right)) ;
 506                         }
 507                 break;
 508                 case T_null :
 509                         if (rightId == T_String) {
 510                                 return Constant.fromValue(false);
 511                         } else {
 512                                 if (rightId == T_null) {
 513                                         return Constant.fromValue(true) ;
 514                                 }
 515                         }
 516                 }
 517
 518         return Constant.fromValue(false)  ;}
 519 public static final Constant computeConstantOperationGREATER(Constant left, int leftId, int operator, Constant right, int rightId) {
 520         //this method  assumes that the TC has been done .
 521
 522         switch (leftId){
 523                 case T_char :
 524                         switch (rightId){
 525                                 case T_char :   return Constant.fromValue(left.charValue() > right.charValue()) ;
 526                                 case T_float:   return Constant.fromValue(left.charValue() > right.floatValue()) ;
 527                                 case T_double:  return Constant.fromValue(left.charValue() > right.doubleValue()) ;
 528                                 case T_byte:    return Constant.fromValue(left.charValue() > right.byteValue()) ;
 529                                 case T_short:   return Constant.fromValue(left.charValue() > right.shortValue()) ;
 530                                 case T_int:             return Constant.fromValue(left.charValue() > right.intValue()) ;
 531                                 case T_long:    return Constant.fromValue(left.charValue() > right.longValue()) ;}
 532                 break;
 533                 case T_float :
 534                         switch (rightId){
 535                                 case T_char :   return Constant.fromValue(left.floatValue() > right.charValue()) ;
 536                                 case T_float:   return Constant.fromValue(left.floatValue() > right.floatValue()) ;
 537                                 case T_double:  return Constant.fromValue(left.floatValue() > right.doubleValue()) ;
 538                                 case T_byte:    return Constant.fromValue(left.floatValue() > right.byteValue()) ;
 539                                 case T_short:   return Constant.fromValue(left.floatValue() > right.shortValue()) ;
 540                                 case T_int:             return Constant.fromValue(left.floatValue() > right.intValue()) ;
 541                                 case T_long:    return Constant.fromValue(left.floatValue() > right.longValue()) ;}
 542                 break;
 543                 case T_double :
 544                         switch (rightId){
 545                                 case T_char :   return Constant.fromValue(left.doubleValue() > right.charValue()) ;
 546                                 case T_float:   return Constant.fromValue(left.doubleValue() > right.floatValue()) ;
 547                                 case T_double:  return Constant.fromValue(left.doubleValue() > right.doubleValue()) ;
 548                                 case T_byte:    return Constant.fromValue(left.doubleValue() > right.byteValue()) ;
 549                                 case T_short:   return Constant.fromValue(left.doubleValue() > right.shortValue()) ;
 550                                 case T_int:             return Constant.fromValue(left.doubleValue() > right.intValue()) ;
 551                                 case T_long:    return Constant.fromValue(left.doubleValue() > right.longValue()) ;}
 552                 break;
 553                 case T_byte :
 554                         switch (rightId){
 555                                 case T_char :   return Constant.fromValue(left.byteValue() > right.charValue()) ;
 556                                 case T_float:   return Constant.fromValue(left.byteValue() > right.floatValue()) ;
 557                                 case T_double:  return Constant.fromValue(left.byteValue() > right.doubleValue()) ;
 558                                 case T_byte:    return Constant.fromValue(left.byteValue() > right.byteValue()) ;
 559                                 case T_short:   return Constant.fromValue(left.byteValue() > right.shortValue()) ;
 560                                 case T_int:             return Constant.fromValue(left.byteValue() > right.intValue()) ;
 561                                 case T_long:    return Constant.fromValue(left.byteValue() > right.longValue()) ;}
 562                 break;
 563                 case T_short :
 564                         switch (rightId){
 565                                 case T_char :   return Constant.fromValue(left.shortValue() > right.charValue()) ;
 566                                 case T_float:   return Constant.fromValue(left.shortValue() > right.floatValue()) ;
 567                                 case T_double:  return Constant.fromValue(left.shortValue() > right.doubleValue()) ;
 568                                 case T_byte:    return Constant.fromValue(left.shortValue() > right.byteValue()) ;
 569                                 case T_short:   return Constant.fromValue(left.shortValue() > right.shortValue()) ;
 570                                 case T_int:             return Constant.fromValue(left.shortValue() > right.intValue()) ;
 571                                 case T_long:    return Constant.fromValue(left.shortValue() > right.longValue()) ;}
 572                 break;
 573                 case T_int :
 574                         switch (rightId){
 575                                 case T_char :   return Constant.fromValue(left.intValue() > right.charValue()) ;
 576                                 case T_float:   return Constant.fromValue(left.intValue() > right.floatValue()) ;
 577                                 case T_double:  return Constant.fromValue(left.intValue() > right.doubleValue()) ;
 578                                 case T_byte:    return Constant.fromValue(left.intValue() > right.byteValue()) ;
 579                                 case T_short:   return Constant.fromValue(left.intValue() > right.shortValue()) ;
 580                                 case T_int:             return Constant.fromValue(left.intValue() > right.intValue()) ;
 581                                 case T_long:    return Constant.fromValue(left.intValue() > right.longValue()) ;}
 582                 break;
 583                 case T_long :
 584                         switch (rightId){
 585                                 case T_char :   return Constant.fromValue(left.longValue() > right.charValue()) ;
 586                                 case T_float:   return Constant.fromValue(left.longValue() > right.floatValue()) ;
 587                                 case T_double:  return Constant.fromValue(left.longValue() > right.doubleValue()) ;
 588                                 case T_byte:    return Constant.fromValue(left.longValue() > right.byteValue()) ;
 589                                 case T_short:   return Constant.fromValue(left.longValue() > right.shortValue()) ;
 590                                 case T_int:             return Constant.fromValue(left.longValue() > right.intValue()) ;
 591                                 case T_long:    return Constant.fromValue(left.longValue() > right.longValue()) ;}
 592
 593                 }
 594
 595         return NotAConstant ;}  //should not get here
 596 public static final Constant computeConstantOperationGREATER_EQUAL(Constant left, int leftId, int operator, Constant right, int rightId) {
 597         //this method  assumes that the TC has been done .
 598
 599         switch (leftId){
 600                 case T_char :
 601                         switch (rightId){
 602                                 case T_char :   return Constant.fromValue(left.charValue() >= right.charValue()) ;
 603                                 case T_float:   return Constant.fromValue(left.charValue() >= right.floatValue()) ;
 604                                 case T_double:  return Constant.fromValue(left.charValue() >= right.doubleValue()) ;
 605                                 case T_byte:    return Constant.fromValue(left.charValue() >= right.byteValue()) ;
 606                                 case T_short:   return Constant.fromValue(left.charValue() >= right.shortValue()) ;
 607                                 case T_int:             return Constant.fromValue(left.charValue() >= right.intValue()) ;
 608                                 case T_long:    return Constant.fromValue(left.charValue() >= right.longValue()) ;}
 609                 break;
 610                 case T_float :
 611                         switch (rightId){
 612                                 case T_char :   return Constant.fromValue(left.floatValue() >= right.charValue()) ;
 613                                 case T_float:   return Constant.fromValue(left.floatValue() >= right.floatValue()) ;
 614                                 case T_double:  return Constant.fromValue(left.floatValue() >= right.doubleValue()) ;
 615                                 case T_byte:    return Constant.fromValue(left.floatValue() >= right.byteValue()) ;
 616                                 case T_short:   return Constant.fromValue(left.floatValue() >= right.shortValue()) ;
 617                                 case T_int:             return Constant.fromValue(left.floatValue() >= right.intValue()) ;
 618                                 case T_long:    return Constant.fromValue(left.floatValue() >= right.longValue()) ;}
 619                 break;
 620                 case T_double :
 621                         switch (rightId){
 622                                 case T_char :   return Constant.fromValue(left.doubleValue() >= right.charValue()) ;
 623                                 case T_float:   return Constant.fromValue(left.doubleValue() >= right.floatValue()) ;
 624                                 case T_double:  return Constant.fromValue(left.doubleValue() >= right.doubleValue()) ;
 625                                 case T_byte:    return Constant.fromValue(left.doubleValue() >= right.byteValue()) ;
 626                                 case T_short:   return Constant.fromValue(left.doubleValue() >= right.shortValue()) ;
 627                                 case T_int:             return Constant.fromValue(left.doubleValue() >= right.intValue()) ;
 628                                 case T_long:    return Constant.fromValue(left.doubleValue() >= right.longValue()) ;}
 629                 break;
 630                 case T_byte :
 631                         switch (rightId){
 632                                 case T_char :   return Constant.fromValue(left.byteValue() >= right.charValue()) ;
 633                                 case T_float:   return Constant.fromValue(left.byteValue() >= right.floatValue()) ;
 634                                 case T_double:  return Constant.fromValue(left.byteValue() >= right.doubleValue()) ;
 635                                 case T_byte:    return Constant.fromValue(left.byteValue() >= right.byteValue()) ;
 636                                 case T_short:   return Constant.fromValue(left.byteValue() >= right.shortValue()) ;
 637                                 case T_int:             return Constant.fromValue(left.byteValue() >= right.intValue()) ;
 638                                 case T_long:    return Constant.fromValue(left.byteValue() >= right.longValue()) ;}
 639                 break;
 640                 case T_short :
 641                         switch (rightId){
 642                                 case T_char :   return Constant.fromValue(left.shortValue() >= right.charValue()) ;
 643                                 case T_float:   return Constant.fromValue(left.shortValue() >= right.floatValue()) ;
 644                                 case T_double:  return Constant.fromValue(left.shortValue() >= right.doubleValue()) ;
 645                                 case T_byte:    return Constant.fromValue(left.shortValue() >= right.byteValue()) ;
 646                                 case T_short:   return Constant.fromValue(left.shortValue() >= right.shortValue()) ;
 647                                 case T_int:             return Constant.fromValue(left.shortValue() >= right.intValue()) ;
 648                                 case T_long:    return Constant.fromValue(left.shortValue() >= right.longValue()) ;}
 649                 break;
 650                 case T_int :
 651                         switch (rightId){
 652                                 case T_char :   return Constant.fromValue(left.intValue() >= right.charValue()) ;
 653                                 case T_float:   return Constant.fromValue(left.intValue() >= right.floatValue()) ;
 654                                 case T_double:  return Constant.fromValue(left.intValue() >= right.doubleValue()) ;
 655                                 case T_byte:    return Constant.fromValue(left.intValue() >= right.byteValue()) ;
 656                                 case T_short:   return Constant.fromValue(left.intValue() >= right.shortValue()) ;
 657                                 case T_int:             return Constant.fromValue(left.intValue() >= right.intValue()) ;
 658                                 case T_long:    return Constant.fromValue(left.intValue() >= right.longValue()) ;}
 659                 break;
 660                 case T_long :
 661                         switch (rightId){
 662                                 case T_char :   return Constant.fromValue(left.longValue() >= right.charValue()) ;
 663                                 case T_float:   return Constant.fromValue(left.longValue() >= right.floatValue()) ;
 664                                 case T_double:  return Constant.fromValue(left.longValue() >= right.doubleValue()) ;
 665                                 case T_byte:    return Constant.fromValue(left.longValue() >= right.byteValue()) ;
 666                                 case T_short:   return Constant.fromValue(left.longValue() >= right.shortValue()) ;
 667                                 case T_int:             return Constant.fromValue(left.longValue() >= right.intValue()) ;
 668                                 case T_long:    return Constant.fromValue(left.longValue() >= right.longValue()) ;}
 669
 670                 }
 671
 672         return NotAConstant ;}  //should not get here
 673 public static final Constant computeConstantOperationLEFT_SHIFT(Constant left, int leftId, int operator, Constant right, int rightId) {
 674         //this method  assumes that the TC has been done .
 675
 676         switch (leftId){
 677                 case T_char :
 678                         switch (rightId){
 679                                 case T_char :   return Constant.fromValue(left.charValue() << right.charValue()) ;
 680                                 case T_byte:    return Constant.fromValue(left.charValue() << right.byteValue()) ;
 681                                 case T_short:   return Constant.fromValue(left.charValue() << right.shortValue()) ;
 682                                 case T_int:             return Constant.fromValue(left.charValue() << right.intValue()) ;
 683                                 case T_long:    return Constant.fromValue(left.charValue() << right.longValue()) ;}
 684                 break ;
 685                 case T_byte :
 686                         switch (rightId){
 687                                 case T_char :   return Constant.fromValue(left.byteValue() << right.charValue()) ;
 688                                 case T_byte:    return Constant.fromValue(left.byteValue() << right.byteValue()) ;
 689                                 case T_short:   return Constant.fromValue(left.byteValue() << right.shortValue()) ;
 690                                 case T_int:             return Constant.fromValue(left.byteValue() << right.intValue()) ;
 691                                 case T_long:    return Constant.fromValue(left.byteValue() << right.longValue()) ;}
 692                 break;
 693                 case T_short :
 694                         switch (rightId){
 695                                 case T_char :   return Constant.fromValue(left.shortValue() << right.charValue()) ;
 696                                 case T_byte:    return Constant.fromValue(left.shortValue() << right.byteValue()) ;
 697                                 case T_short:   return Constant.fromValue(left.shortValue() << right.shortValue()) ;
 698                                 case T_int:             return Constant.fromValue(left.shortValue() << right.intValue()) ;
 699                                 case T_long:    return Constant.fromValue(left.shortValue() << right.longValue()) ;}
 700                 break;
 701                 case T_int :
 702                         switch (rightId){
 703                                 case T_char :   return Constant.fromValue(left.intValue() << right.charValue()) ;
 704                                 case T_byte:    return Constant.fromValue(left.intValue() << right.byteValue()) ;
 705                                 case T_short:   return Constant.fromValue(left.intValue() << right.shortValue()) ;
 706                                 case T_int:             return Constant.fromValue(left.intValue() << right.intValue()) ;
 707                                 case T_long:    return Constant.fromValue(left.intValue() << right.longValue()) ;}
 708                 break;
 709                 case T_long :
 710                         switch (rightId){
 711                                 case T_char :   return Constant.fromValue(left.longValue() << right.charValue()) ;
 712                                 case T_byte:    return Constant.fromValue(left.longValue() << right.byteValue()) ;
 713                                 case T_short:   return Constant.fromValue(left.longValue() << right.shortValue()) ;
 714                                 case T_int:             return Constant.fromValue(left.longValue() << right.intValue()) ;
 715                                 case T_long:    return Constant.fromValue(left.longValue() << right.longValue()) ;}
 716
 717                 }
 718
 719
 720         return NotAConstant ;}  // should not get here
 721 public static final Constant computeConstantOperationLESS(Constant left, int leftId, int operator, Constant right, int rightId) {
 722         //this method  assumes that the TC has been done .
 723
 724         switch (leftId){
 725                 case T_char :
 726                         switch (rightId){
 727                                 case T_char :   return Constant.fromValue(left.charValue() < right.charValue()) ;
 728                                 case T_float:   return Constant.fromValue(left.charValue() < right.floatValue()) ;
 729                                 case T_double:  return Constant.fromValue(left.charValue() < right.doubleValue()) ;
 730                                 case T_byte:    return Constant.fromValue(left.charValue() < right.byteValue()) ;
 731                                 case T_short:   return Constant.fromValue(left.charValue() < right.shortValue()) ;
 732                                 case T_int:             return Constant.fromValue(left.charValue() < right.intValue()) ;
 733                                 case T_long:    return Constant.fromValue(left.charValue() < right.longValue()) ;}
 734                 break;
 735                 case T_float :
 736                         switch (rightId){
 737                                 case T_char :   return Constant.fromValue(left.floatValue() < right.charValue()) ;
 738                                 case T_float:   return Constant.fromValue(left.floatValue() < right.floatValue()) ;
 739                                 case T_double:  return Constant.fromValue(left.floatValue() < right.doubleValue()) ;
 740                                 case T_byte:    return Constant.fromValue(left.floatValue() < right.byteValue()) ;
 741                                 case T_short:   return Constant.fromValue(left.floatValue() < right.shortValue()) ;
 742                                 case T_int:             return Constant.fromValue(left.floatValue() < right.intValue()) ;
 743                                 case T_long:    return Constant.fromValue(left.floatValue() < right.longValue()) ;}
 744                 break;
 745                 case T_double :
 746                         switch (rightId){
 747                                 case T_char :   return Constant.fromValue(left.doubleValue() < right.charValue()) ;
 748                                 case T_float:   return Constant.fromValue(left.doubleValue() < right.floatValue()) ;
 749                                 case T_double:  return Constant.fromValue(left.doubleValue() < right.doubleValue()) ;
 750                                 case T_byte:    return Constant.fromValue(left.doubleValue() < right.byteValue()) ;
 751                                 case T_short:   return Constant.fromValue(left.doubleValue() < right.shortValue()) ;
 752                                 case T_int:             return Constant.fromValue(left.doubleValue() < right.intValue()) ;
 753                                 case T_long:    return Constant.fromValue(left.doubleValue() < right.longValue()) ;}
 754                 break;
 755                 case T_byte :
 756                         switch (rightId){
 757                                 case T_char :   return Constant.fromValue(left.byteValue() < right.charValue()) ;
 758                                 case T_float:   return Constant.fromValue(left.byteValue() < right.floatValue()) ;
 759                                 case T_double:  return Constant.fromValue(left.byteValue() < right.doubleValue()) ;
 760                                 case T_byte:    return Constant.fromValue(left.byteValue() < right.byteValue()) ;
 761                                 case T_short:   return Constant.fromValue(left.byteValue() < right.shortValue()) ;
 762                                 case T_int:             return Constant.fromValue(left.byteValue() < right.intValue()) ;
 763                                 case T_long:    return Constant.fromValue(left.byteValue() < right.longValue()) ;}
 764                 break;
 765                 case T_short :
 766                         switch (rightId){
 767                                 case T_char :   return Constant.fromValue(left.shortValue() < right.charValue()) ;
 768                                 case T_float:   return Constant.fromValue(left.shortValue() < right.floatValue()) ;
 769                                 case T_double:  return Constant.fromValue(left.shortValue() < right.doubleValue()) ;
 770                                 case T_byte:    return Constant.fromValue(left.shortValue() < right.byteValue()) ;
 771                                 case T_short:   return Constant.fromValue(left.shortValue() < right.shortValue()) ;
 772                                 case T_int:             return Constant.fromValue(left.shortValue() < right.intValue()) ;
 773                                 case T_long:    return Constant.fromValue(left.shortValue() < right.longValue()) ;}
 774                 break;
 775                 case T_int :
 776                         switch (rightId){
 777                                 case T_char :   return Constant.fromValue(left.intValue() < right.charValue()) ;
 778                                 case T_float:   return Constant.fromValue(left.intValue() < right.floatValue()) ;
 779                                 case T_double:  return Constant.fromValue(left.intValue() < right.doubleValue()) ;
 780                                 case T_byte:    return Constant.fromValue(left.intValue() < right.byteValue()) ;
 781                                 case T_short:   return Constant.fromValue(left.intValue() < right.shortValue()) ;
 782                                 case T_int:             return Constant.fromValue(left.intValue() < right.intValue()) ;
 783                                 case T_long:    return Constant.fromValue(left.intValue() < right.longValue()) ;}
 784                 break;
 785                 case T_long :
 786                         switch (rightId){
 787                                 case T_char :   return Constant.fromValue(left.longValue() < right.charValue()) ;
 788                                 case T_float:   return Constant.fromValue(left.longValue() < right.floatValue()) ;
 789                                 case T_double:  return Constant.fromValue(left.longValue() < right.doubleValue()) ;
 790                                 case T_byte:    return Constant.fromValue(left.longValue() < right.byteValue()) ;
 791                                 case T_short:   return Constant.fromValue(left.longValue() < right.shortValue()) ;
 792                                 case T_int:             return Constant.fromValue(left.longValue() < right.intValue()) ;
 793                                 case T_long:    return Constant.fromValue(left.longValue() < right.longValue()) ;}
 794
 795                 }
 796
 797         return NotAConstant ;}  //should not get here
 798 public static final Constant computeConstantOperationLESS_EQUAL(Constant left, int leftId, int operator, Constant right, int rightId) {
 799         //this method  assumes that the TC has been done .
 800
 801         switch (leftId){
 802                 case T_char :
 803                         switch (rightId){
 804                                 case T_char :   return Constant.fromValue(left.charValue() <= right.charValue()) ;
 805                                 case T_float:   return Constant.fromValue(left.charValue() <= right.floatValue()) ;
 806                                 case T_double:  return Constant.fromValue(left.charValue() <= right.doubleValue()) ;
 807                                 case T_byte:    return Constant.fromValue(left.charValue() <= right.byteValue()) ;
 808                                 case T_short:   return Constant.fromValue(left.charValue() <= right.shortValue()) ;
 809                                 case T_int:             return Constant.fromValue(left.charValue() <= right.intValue()) ;
 810                                 case T_long:    return Constant.fromValue(left.charValue() <= right.longValue()) ;}
 811                 break;
 812                 case T_float :
 813                         switch (rightId){
 814                                 case T_char :   return Constant.fromValue(left.floatValue() <= right.charValue()) ;
 815                                 case T_float:   return Constant.fromValue(left.floatValue() <= right.floatValue()) ;
 816                                 case T_double:  return Constant.fromValue(left.floatValue() <= right.doubleValue()) ;
 817                                 case T_byte:    return Constant.fromValue(left.floatValue() <= right.byteValue()) ;
 818                                 case T_short:   return Constant.fromValue(left.floatValue() <= right.shortValue()) ;
 819                                 case T_int:             return Constant.fromValue(left.floatValue() <= right.intValue()) ;
 820                                 case T_long:    return Constant.fromValue(left.floatValue() <= right.longValue()) ;}
 821                 break;
 822                 case T_double :
 823                         switch (rightId){
 824                                 case T_char :   return Constant.fromValue(left.doubleValue() <= right.charValue()) ;
 825                                 case T_float:   return Constant.fromValue(left.doubleValue() <= right.floatValue()) ;
 826                                 case T_double:  return Constant.fromValue(left.doubleValue() <= right.doubleValue()) ;
 827                                 case T_byte:    return Constant.fromValue(left.doubleValue() <= right.byteValue()) ;
 828                                 case T_short:   return Constant.fromValue(left.doubleValue() <= right.shortValue()) ;
 829                                 case T_int:             return Constant.fromValue(left.doubleValue() <= right.intValue()) ;
 830                                 case T_long:    return Constant.fromValue(left.doubleValue() <= right.longValue()) ;}
 831                 break;
 832                 case T_byte :
 833                         switch (rightId){
 834                                 case T_char :   return Constant.fromValue(left.byteValue() <= right.charValue()) ;
 835                                 case T_float:   return Constant.fromValue(left.byteValue() <= right.floatValue()) ;
 836                                 case T_double:  return Constant.fromValue(left.byteValue() <= right.doubleValue()) ;
 837                                 case T_byte:    return Constant.fromValue(left.byteValue() <= right.byteValue()) ;
 838                                 case T_short:   return Constant.fromValue(left.byteValue() <= right.shortValue()) ;
 839                                 case T_int:             return Constant.fromValue(left.byteValue() <= right.intValue()) ;
 840                                 case T_long:    return Constant.fromValue(left.byteValue() <= right.longValue()) ;}
 841                 break;
 842                 case T_short :
 843                         switch (rightId){
 844                                 case T_char :   return Constant.fromValue(left.shortValue() <= right.charValue()) ;
 845                                 case T_float:   return Constant.fromValue(left.shortValue() <= right.floatValue()) ;
 846                                 case T_double:  return Constant.fromValue(left.shortValue() <= right.doubleValue()) ;
 847                                 case T_byte:    return Constant.fromValue(left.shortValue() <= right.byteValue()) ;
 848                                 case T_short:   return Constant.fromValue(left.shortValue() <= right.shortValue()) ;
 849                                 case T_int:             return Constant.fromValue(left.shortValue() <= right.intValue()) ;
 850                                 case T_long:    return Constant.fromValue(left.shortValue() <= right.longValue()) ;}
 851                 break;
 852                 case T_int :
 853                         switch (rightId){
 854                                 case T_char :   return Constant.fromValue(left.intValue() <= right.charValue()) ;
 855                                 case T_float:   return Constant.fromValue(left.intValue() <= right.floatValue()) ;
 856                                 case T_double:  return Constant.fromValue(left.intValue() <= right.doubleValue()) ;
 857                                 case T_byte:    return Constant.fromValue(left.intValue() <= right.byteValue()) ;
 858                                 case T_short:   return Constant.fromValue(left.intValue() <= right.shortValue()) ;
 859                                 case T_int:             return Constant.fromValue(left.intValue() <= right.intValue()) ;
 860                                 case T_long:    return Constant.fromValue(left.intValue() <= right.longValue()) ;}
 861                 break;
 862                 case T_long :
 863                         switch (rightId){
 864                                 case T_char :   return Constant.fromValue(left.longValue() <= right.charValue()) ;
 865                                 case T_float:   return Constant.fromValue(left.longValue() <= right.floatValue()) ;
 866                                 case T_double:  return Constant.fromValue(left.longValue() <= right.doubleValue()) ;
 867                                 case T_byte:    return Constant.fromValue(left.longValue() <= right.byteValue()) ;
 868                                 case T_short:   return Constant.fromValue(left.longValue() <= right.shortValue()) ;
 869                                 case T_int:             return Constant.fromValue(left.longValue() <= right.intValue()) ;
 870                                 case T_long:    return Constant.fromValue(left.longValue() <= right.longValue()) ;}
 871
 872                 }
 873
 874         return NotAConstant ;}  //should not get here
 875 public static final Constant computeConstantOperationMINUS(Constant left, int leftId, int operator, Constant right, int rightId) {
 876         //this method  assumes that the TC has been done .
 877
 878         switch (leftId){
 879                 case T_char :
 880                         switch (rightId){
 881                                 case T_char :   return Constant.fromValue(left.charValue() - right.charValue()) ;
 882                                 case T_float:   return Constant.fromValue(left.charValue() - right.floatValue()) ;
 883                                 case T_double:  return Constant.fromValue(left.charValue() - right.doubleValue()) ;
 884                                 case T_byte:    return Constant.fromValue(left.charValue() - right.byteValue()) ;
 885                                 case T_short:   return Constant.fromValue(left.charValue() - right.shortValue()) ;
 886                                 case T_int:             return Constant.fromValue(left.charValue() - right.intValue()) ;
 887                                 case T_long:    return Constant.fromValue(left.charValue() - right.longValue()) ;}
 888                 break;
 889                 case T_float :
 890                         switch (rightId){
 891                                 case T_char :   return Constant.fromValue(left.floatValue() - right.charValue()) ;
 892                                 case T_float:   return Constant.fromValue(left.floatValue() - right.floatValue()) ;
 893                                 case T_double:  return Constant.fromValue(left.floatValue() - right.doubleValue()) ;
 894                                 case T_byte:    return Constant.fromValue(left.floatValue() - right.byteValue()) ;
 895                                 case T_short:   return Constant.fromValue(left.floatValue() - right.shortValue()) ;
 896                                 case T_int:             return Constant.fromValue(left.floatValue() - right.intValue()) ;
 897                                 case T_long:    return Constant.fromValue(left.floatValue() - right.longValue()) ;}
 898                 break;
 899                 case T_double :
 900                         switch (rightId){
 901                                 case T_char :   return Constant.fromValue(left.doubleValue() - right.charValue()) ;
 902                                 case T_float:   return Constant.fromValue(left.doubleValue() - right.floatValue()) ;
 903                                 case T_double:  return Constant.fromValue(left.doubleValue() - right.doubleValue()) ;
 904                                 case T_byte:    return Constant.fromValue(left.doubleValue() - right.byteValue()) ;
 905                                 case T_short:   return Constant.fromValue(left.doubleValue() - right.shortValue()) ;
 906                                 case T_int:             return Constant.fromValue(left.doubleValue() - right.intValue()) ;
 907                                 case T_long:    return Constant.fromValue(left.doubleValue() - right.longValue()) ;}
 908                 break;
 909                 case T_byte :
 910                         switch (rightId){
 911                                 case T_char :   return Constant.fromValue(left.byteValue() - right.charValue()) ;
 912                                 case T_float:   return Constant.fromValue(left.byteValue() - right.floatValue()) ;
 913                                 case T_double:  return Constant.fromValue(left.byteValue() - right.doubleValue()) ;
 914                                 case T_byte:    return Constant.fromValue(left.byteValue() - right.byteValue()) ;
 915                                 case T_short:   return Constant.fromValue(left.byteValue() - right.shortValue()) ;
 916                                 case T_int:             return Constant.fromValue(left.byteValue() - right.intValue()) ;
 917                                 case T_long:    return Constant.fromValue(left.byteValue() - right.longValue()) ;}
 918                 break;
 919                 case T_short :
 920                         switch (rightId){
 921                                 case T_char :   return Constant.fromValue(left.shortValue() - right.charValue()) ;
 922                                 case T_float:   return Constant.fromValue(left.shortValue() - right.floatValue()) ;
 923                                 case T_double:  return Constant.fromValue(left.shortValue() - right.doubleValue()) ;
 924                                 case T_byte:    return Constant.fromValue(left.shortValue() - right.byteValue()) ;
 925                                 case T_short:   return Constant.fromValue(left.shortValue() - right.shortValue()) ;
 926                                 case T_int:             return Constant.fromValue(left.shortValue() - right.intValue()) ;
 927                                 case T_long:    return Constant.fromValue(left.shortValue() - right.longValue()) ;}
 928                 break;
 929                 case T_int :
 930                         switch (rightId){
 931                                 case T_char :   return Constant.fromValue(left.intValue() - right.charValue()) ;
 932                                 case T_float:   return Constant.fromValue(left.intValue() - right.floatValue()) ;
 933                                 case T_double:  return Constant.fromValue(left.intValue() - right.doubleValue()) ;
 934                                 case T_byte:    return Constant.fromValue(left.intValue() - right.byteValue()) ;
 935                                 case T_short:   return Constant.fromValue(left.intValue() - right.shortValue()) ;
 936                                 case T_int:             return Constant.fromValue(left.intValue() - right.intValue()) ;
 937                                 case T_long:    return Constant.fromValue(left.intValue() - right.longValue()) ;}
 938                 break;
 939                 case T_long :
 940                         switch (rightId){
 941                                 case T_char :   return Constant.fromValue(left.longValue() - right.charValue()) ;
 942                                 case T_float:   return Constant.fromValue(left.longValue() - right.floatValue()) ;
 943                                 case T_double:  return Constant.fromValue(left.longValue() - right.doubleValue()) ;
 944                                 case T_byte:    return Constant.fromValue(left.longValue() - right.byteValue()) ;
 945                                 case T_short:   return Constant.fromValue(left.longValue() - right.shortValue()) ;
 946                                 case T_int:             return Constant.fromValue(left.longValue() - right.intValue()) ;
 947                                 case T_long:    return Constant.fromValue(left.longValue() - right.longValue()) ;}
 948
 949                 }
 950
 951         return NotAConstant ;}  //should not get here
 952 public static final Constant computeConstantOperationMULTIPLY(Constant left, int leftId, int operator, Constant right, int rightId) {
 953         //this method  assumes that the TC has been done .
 954
 955         switch (leftId){
 956                 case T_char :
 957                         switch (rightId){
 958                                 case T_char :   return Constant.fromValue(left.charValue() * right.charValue()) ;
 959                                 case T_float:   return Constant.fromValue(left.charValue() * right.floatValue()) ;
 960                                 case T_double:  return Constant.fromValue(left.charValue() * right.doubleValue()) ;
 961                                 case T_byte:    return Constant.fromValue(left.charValue() * right.byteValue()) ;
 962                                 case T_short:   return Constant.fromValue(left.charValue() * right.shortValue()) ;
 963                                 case T_int:             return Constant.fromValue(left.charValue() * right.intValue()) ;
 964                                 case T_long:    return Constant.fromValue(left.charValue() * right.longValue()) ;}
 965                 break;
 966                 case T_float :
 967                         switch (rightId){
 968                                 case T_char :   return Constant.fromValue(left.floatValue() * right.charValue()) ;
 969                                 case T_float:   return Constant.fromValue(left.floatValue() * right.floatValue()) ;
 970                                 case T_double:  return Constant.fromValue(left.floatValue() * right.doubleValue()) ;
 971                                 case T_byte:    return Constant.fromValue(left.floatValue() * right.byteValue()) ;
 972                                 case T_short:   return Constant.fromValue(left.floatValue() * right.shortValue()) ;
 973                                 case T_int:             return Constant.fromValue(left.floatValue() * right.intValue()) ;
 974                                 case T_long:    return Constant.fromValue(left.floatValue() * right.longValue()) ;}
 975                 break;
 976                 case T_double :
 977                         switch (rightId){
 978                                 case T_char :   return Constant.fromValue(left.doubleValue() * right.charValue()) ;
 979                                 case T_float:   return Constant.fromValue(left.doubleValue() * right.floatValue()) ;
 980                                 case T_double:  return Constant.fromValue(left.doubleValue() * right.doubleValue()) ;
 981                                 case T_byte:    return Constant.fromValue(left.doubleValue() * right.byteValue()) ;
 982                                 case T_short:   return Constant.fromValue(left.doubleValue() * right.shortValue()) ;
 983                                 case T_int:             return Constant.fromValue(left.doubleValue() * right.intValue()) ;
 984                                 case T_long:    return Constant.fromValue(left.doubleValue() * right.longValue()) ;}
 985                 break;
 986                 case T_byte :
 987                         switch (rightId){
 988                                 case T_char :   return Constant.fromValue(left.byteValue() * right.charValue()) ;
 989                                 case T_float:   return Constant.fromValue(left.byteValue() * right.floatValue()) ;
 990                                 case T_double:  return Constant.fromValue(left.byteValue() * right.doubleValue()) ;
 991                                 case T_byte:    return Constant.fromValue(left.byteValue() * right.byteValue()) ;
 992                                 case T_short:   return Constant.fromValue(left.byteValue() * right.shortValue()) ;
 993                                 case T_int:             return Constant.fromValue(left.byteValue() * right.intValue()) ;
 994                                 case T_long:    return Constant.fromValue(left.byteValue() * right.longValue()) ;}
 995                 break;
 996                 case T_short :
 997                         switch (rightId){
 998                                 case T_char :   return Constant.fromValue(left.shortValue() * right.charValue()) ;
 999                                 case T_float:   return Constant.fromValue(left.shortValue() * right.floatValue()) ;
1000                                 case T_double:  return Constant.fromValue(left.shortValue() * right.doubleValue()) ;
1001                                 case T_byte:    return Constant.fromValue(left.shortValue() * right.byteValue()) ;
1002                                 case T_short:   return Constant.fromValue(left.shortValue() * right.shortValue()) ;
1003                                 case T_int:             return Constant.fromValue(left.shortValue() * right.intValue()) ;
1004                                 case T_long:    return Constant.fromValue(left.shortValue() * right.longValue()) ;}
1005                 break;
1006                 case T_int :
1007                         switch (rightId){
1008                                 case T_char :   return Constant.fromValue(left.intValue() * right.charValue()) ;
1009                                 case T_float:   return Constant.fromValue(left.intValue() * right.floatValue()) ;
1010                                 case T_double:  return Constant.fromValue(left.intValue() * right.doubleValue()) ;
1011                                 case T_byte:    return Constant.fromValue(left.intValue() * right.byteValue()) ;
1012                                 case T_short:   return Constant.fromValue(left.intValue() * right.shortValue()) ;
1013                                 case T_int:             return Constant.fromValue(left.intValue() * right.intValue()) ;
1014                                 case T_long:    return Constant.fromValue(left.intValue() * right.longValue()) ;}
1015                 break;
1016                 case T_long :
1017                         switch (rightId){
1018                                 case T_char :   return Constant.fromValue(left.longValue() * right.charValue()) ;
1019                                 case T_float:   return Constant.fromValue(left.longValue() * right.floatValue()) ;
1020                                 case T_double:  return Constant.fromValue(left.longValue() * right.doubleValue()) ;
1021                                 case T_byte:    return Constant.fromValue(left.longValue() * right.byteValue()) ;
1022                                 case T_short:   return Constant.fromValue(left.longValue() * right.shortValue()) ;
1023                                 case T_int:             return Constant.fromValue(left.longValue() * right.intValue()) ;
1024                                 case T_long:    return Constant.fromValue(left.longValue() * right.longValue()) ;}
1025
1026                 }
1027
1028
1029         return NotAConstant ;}  //should not get here
1030 public static final Constant computeConstantOperationOR(Constant left, int leftId, int operator, Constant right, int rightId) {
1031         //this method  assumes that the TC has been done .
1032
1033         switch (leftId){
1034                 case T_boolean :                return Constant.fromValue(left.booleanValue() | right.booleanValue()) ;
1035                 case T_char :
1036                         switch (rightId){
1037                                 case T_char :   return Constant.fromValue(left.charValue() | right.charValue()) ;
1038                                 case T_byte:    return Constant.fromValue(left.charValue() | right.byteValue()) ;
1039                                 case T_short:   return Constant.fromValue(left.charValue() | right.shortValue()) ;
1040                                 case T_int:             return Constant.fromValue(left.charValue() | right.intValue()) ;
1041                                 case T_long:    return Constant.fromValue(left.charValue() | right.longValue()) ;}
1042                 break;
1043                 case T_byte :
1044                         switch (rightId){
1045                                 case T_char :   return Constant.fromValue(left.byteValue() | right.charValue()) ;
1046                                 case T_byte:    return Constant.fromValue(left.byteValue() | right.byteValue()) ;
1047                                 case T_short:   return Constant.fromValue(left.byteValue() | right.shortValue()) ;
1048                                 case T_int:             return Constant.fromValue(left.byteValue() | right.intValue()) ;
1049                                 case T_long:    return Constant.fromValue(left.byteValue() | right.longValue()) ;}
1050                 break;
1051                 case T_short :
1052                         switch (rightId){
1053                                 case T_char :   return Constant.fromValue(left.shortValue() | right.charValue()) ;
1054                                 case T_byte:    return Constant.fromValue(left.shortValue() | right.byteValue()) ;
1055                                 case T_short:   return Constant.fromValue(left.shortValue() | right.shortValue()) ;
1056                                 case T_int:             return Constant.fromValue(left.shortValue() | right.intValue()) ;
1057                                 case T_long:    return Constant.fromValue(left.shortValue() | right.longValue()) ;}
1058                 break;
1059                 case T_int :
1060                         switch (rightId){
1061                                 case T_char :   return Constant.fromValue(left.intValue() | right.charValue()) ;
1062                                 case T_byte:    return Constant.fromValue(left.intValue() | right.byteValue()) ;
1063                                 case T_short:   return Constant.fromValue(left.intValue() | right.shortValue()) ;
1064                                 case T_int:             return Constant.fromValue(left.intValue() | right.intValue()) ;
1065                                 case T_long:    return Constant.fromValue(left.intValue() | right.longValue()) ;}
1066                 break;
1067                 case T_long :
1068                         switch (rightId){
1069                                 case T_char :   return Constant.fromValue(left.longValue() | right.charValue()) ;
1070                                 case T_byte:    return Constant.fromValue(left.longValue() | right.byteValue()) ;
1071                                 case T_short:   return Constant.fromValue(left.longValue() | right.shortValue()) ;
1072                                 case T_int:             return Constant.fromValue(left.longValue() | right.intValue()) ;
1073                                 case T_long:    return Constant.fromValue(left.longValue() | right.longValue()) ;}
1074
1075                 }
1076
1077
1078         return NotAConstant ;}  // should not get here
1079 public static final Constant computeConstantOperationOR_OR(Constant left, int leftId, int operator, Constant right, int rightId) {
1080         //this method  assumes that the TC has been done .
1081
1082         return Constant.fromValue(left.booleanValue() || right.booleanValue()) ;}
1083 public static final Constant computeConstantOperationPLUS(Constant left, int leftId, int operator, Constant right, int rightId) {
1084         //this method  assumes that the TC has been done .
1085
1086         switch (leftId){
1087                 case T_Object :
1088                         if (rightId == T_String) {
1089                                 return Constant.fromValue(left.stringValue() + right.stringValue());
1090                         }
1091                 case T_boolean :
1092                         if (rightId == T_String) {
1093                                 return Constant.fromValue(left.stringValue() + right.stringValue());
1094                         }
1095                 break ;
1096                 case T_char :
1097                         switch (rightId){
1098                                 case T_char :   return Constant.fromValue(left.charValue() + right.charValue()) ;
1099                                 case T_float:   return Constant.fromValue(left.charValue() + right.floatValue()) ;
1100                                 case T_double:  return Constant.fromValue(left.charValue() + right.doubleValue()) ;
1101                                 case T_byte:    return Constant.fromValue(left.charValue() + right.byteValue()) ;
1102                                 case T_short:   return Constant.fromValue(left.charValue() + right.shortValue()) ;
1103                                 case T_int:             return Constant.fromValue(left.charValue() + right.intValue()) ;
1104                                 case T_long:    return Constant.fromValue(left.charValue() + right.longValue()) ;
1105                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;}
1106                 break;
1107                 case T_float :
1108                         switch (rightId){
1109                                 case T_char :   return Constant.fromValue(left.floatValue() + right.charValue()) ;
1110                                 case T_float:   return Constant.fromValue(left.floatValue() + right.floatValue()) ;
1111                                 case T_double:  return Constant.fromValue(left.floatValue() + right.doubleValue()) ;
1112                                 case T_byte:    return Constant.fromValue(left.floatValue() + right.byteValue()) ;
1113                                 case T_short:   return Constant.fromValue(left.floatValue() + right.shortValue()) ;
1114                                 case T_int:             return Constant.fromValue(left.floatValue() + right.intValue()) ;
1115                                 case T_long:    return Constant.fromValue(left.floatValue() + right.longValue()) ;
1116                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ; }
1117                 break;
1118                 case T_double :
1119                         switch (rightId){
1120                                 case T_char :   return Constant.fromValue(left.doubleValue() + right.charValue()) ;
1121                                 case T_float:   return Constant.fromValue(left.doubleValue() + right.floatValue()) ;
1122                                 case T_double:  return Constant.fromValue(left.doubleValue() + right.doubleValue()) ;
1123                                 case T_byte:    return Constant.fromValue(left.doubleValue() + right.byteValue()) ;
1124                                 case T_short:   return Constant.fromValue(left.doubleValue() + right.shortValue()) ;
1125                                 case T_int:             return Constant.fromValue(left.doubleValue() + right.intValue()) ;
1126                                 case T_long:    return Constant.fromValue(left.doubleValue() + right.longValue()) ;
1127                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;}
1128                 break;
1129                 case T_byte :
1130                         switch (rightId){
1131                                 case T_char :   return Constant.fromValue(left.byteValue() + right.charValue()) ;
1132                                 case T_float:   return Constant.fromValue(left.byteValue() + right.floatValue()) ;
1133                                 case T_double:  return Constant.fromValue(left.byteValue() + right.doubleValue()) ;
1134                                 case T_byte:    return Constant.fromValue(left.byteValue() + right.byteValue()) ;
1135                                 case T_short:   return Constant.fromValue(left.byteValue() + right.shortValue()) ;
1136                                 case T_int:             return Constant.fromValue(left.byteValue() + right.intValue()) ;
1137                                 case T_long:    return Constant.fromValue(left.byteValue() + right.longValue()) ;
1138                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ; }
1139
1140                 break;
1141                 case T_short :
1142                         switch (rightId){
1143                                 case T_char :   return Constant.fromValue(left.shortValue() + right.charValue()) ;
1144                                 case T_float:   return Constant.fromValue(left.shortValue() + right.floatValue()) ;
1145                                 case T_double:  return Constant.fromValue(left.shortValue() + right.doubleValue()) ;
1146                                 case T_byte:    return Constant.fromValue(left.shortValue() + right.byteValue()) ;
1147                                 case T_short:   return Constant.fromValue(left.shortValue() + right.shortValue()) ;
1148                                 case T_int:             return Constant.fromValue(left.shortValue() + right.intValue()) ;
1149                                 case T_long:    return Constant.fromValue(left.shortValue() + right.longValue()) ;
1150                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;}
1151                 break;
1152                 case T_int :
1153                         switch (rightId){
1154                                 case T_char :   return Constant.fromValue(left.intValue() + right.charValue()) ;
1155                                 case T_float:   return Constant.fromValue(left.intValue() + right.floatValue()) ;
1156                                 case T_double:  return Constant.fromValue(left.intValue() + right.doubleValue()) ;
1157                                 case T_byte:    return Constant.fromValue(left.intValue() + right.byteValue()) ;
1158                                 case T_short:   return Constant.fromValue(left.intValue() + right.shortValue()) ;
1159                                 case T_int:             return Constant.fromValue(left.intValue() + right.intValue()) ;
1160                                 case T_long:    return Constant.fromValue(left.intValue() + right.longValue()) ;
1161                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;}
1162                 break;
1163                 case T_long :
1164                         switch (rightId){
1165                                 case T_char :   return Constant.fromValue(left.longValue() + right.charValue()) ;
1166                                 case T_float:   return Constant.fromValue(left.longValue() + right.floatValue()) ;
1167                                 case T_double:  return Constant.fromValue(left.longValue() + right.doubleValue()) ;
1168                                 case T_byte:    return Constant.fromValue(left.longValue() + right.byteValue()) ;
1169                                 case T_short:   return Constant.fromValue(left.longValue() + right.shortValue()) ;
1170                                 case T_int:             return Constant.fromValue(left.longValue() + right.intValue()) ;
1171                                 case T_long:    return Constant.fromValue(left.longValue() + right.longValue()) ;
1172                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ; }
1173                 break;
1174                 case T_String :
1175                         switch (rightId){
1176                                 case T_char :   return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1177                                 case T_float:   return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1178                                 case T_double:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1179                                 case T_byte:    return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1180                                 case T_short:   return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1181                                 case T_int:             return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1182                                 case T_long:    return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1183                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1184                                 case T_null:    return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1185                                 case T_boolean: return Constant.fromValue(left.stringValue() + right.stringValue()) ;}
1186                 break;
1187                 case T_null :
1188                         switch (rightId){
1189                                 case T_char :   return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1190                                 case T_float:   return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1191                                 case T_double:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1192                                 case T_byte:    return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1193                                 case T_short:   return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1194                                 case T_int:             return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1195                                 case T_long:    return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1196                                 case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()) ;
1197                                 case T_null:    return Constant.fromValue(left.stringValue() + right.stringValue()) ; }
1198
1199                 }
1200
1201         return NotAConstant ;}  //should not get here
1202 public static final Constant computeConstantOperationREMAINDER(Constant left, int leftId, int operator, Constant right, int rightId) {
1203         //this method  assumes that the TC has been done .
1204
1205         switch (leftId){
1206                 case T_char :
1207                         switch (rightId){
1208                                 case T_char :   return Constant.fromValue(left.charValue() % right.charValue()) ;
1209                                 case T_float:   return Constant.fromValue(left.charValue() % right.floatValue()) ;
1210                                 case T_double:  return Constant.fromValue(left.charValue() % right.doubleValue()) ;
1211                                 case T_byte:    return Constant.fromValue(left.charValue() % right.byteValue()) ;
1212                                 case T_short:   return Constant.fromValue(left.charValue() % right.shortValue()) ;
1213                                 case T_int:             return Constant.fromValue(left.charValue() % right.intValue()) ;
1214                                 case T_long:    return Constant.fromValue(left.charValue() % right.longValue()) ;}
1215                 break;
1216                 case T_float :
1217                         switch (rightId){
1218                                 case T_char :   return Constant.fromValue(left.floatValue() % right.charValue()) ;
1219                                 case T_float:   return Constant.fromValue(left.floatValue() % right.floatValue()) ;
1220                                 case T_double:  return Constant.fromValue(left.floatValue() % right.doubleValue()) ;
1221                                 case T_byte:    return Constant.fromValue(left.floatValue() % right.byteValue()) ;
1222                                 case T_short:   return Constant.fromValue(left.floatValue() % right.shortValue()) ;
1223                                 case T_int:             return Constant.fromValue(left.floatValue() % right.intValue()) ;
1224                                 case T_long:    return Constant.fromValue(left.floatValue() % right.longValue()) ;}
1225                 break;
1226                 case T_double :
1227                         switch (rightId){
1228                                 case T_char :   return Constant.fromValue(left.doubleValue() % right.charValue()) ;
1229                                 case T_float:   return Constant.fromValue(left.doubleValue() % right.floatValue()) ;
1230                                 case T_double:  return Constant.fromValue(left.doubleValue() % right.doubleValue()) ;
1231                                 case T_byte:    return Constant.fromValue(left.doubleValue() % right.byteValue()) ;
1232                                 case T_short:   return Constant.fromValue(left.doubleValue() % right.shortValue()) ;
1233                                 case T_int:             return Constant.fromValue(left.doubleValue() % right.intValue()) ;
1234                                 case T_long:    return Constant.fromValue(left.doubleValue() % right.longValue()) ;}
1235                 break;
1236                 case T_byte :
1237                         switch (rightId){
1238                                 case T_char :   return Constant.fromValue(left.byteValue() % right.charValue()) ;
1239                                 case T_float:   return Constant.fromValue(left.byteValue() % right.floatValue()) ;
1240                                 case T_double:  return Constant.fromValue(left.byteValue() % right.doubleValue()) ;
1241                                 case T_byte:    return Constant.fromValue(left.byteValue() % right.byteValue()) ;
1242                                 case T_short:   return Constant.fromValue(left.byteValue() % right.shortValue()) ;
1243                                 case T_int:             return Constant.fromValue(left.byteValue() % right.intValue()) ;
1244                                 case T_long:    return Constant.fromValue(left.byteValue() % right.longValue()) ;}
1245                 break;
1246                 case T_short :
1247                         switch (rightId){
1248                                 case T_char :   return Constant.fromValue(left.shortValue() % right.charValue()) ;
1249                                 case T_float:   return Constant.fromValue(left.shortValue() % right.floatValue()) ;
1250                                 case T_double:  return Constant.fromValue(left.shortValue() % right.doubleValue()) ;
1251                                 case T_byte:    return Constant.fromValue(left.shortValue() % right.byteValue()) ;
1252                                 case T_short:   return Constant.fromValue(left.shortValue() % right.shortValue()) ;
1253                                 case T_int:             return Constant.fromValue(left.shortValue() % right.intValue()) ;
1254                                 case T_long:    return Constant.fromValue(left.shortValue() % right.longValue()) ;}
1255                 break;
1256                 case T_int :
1257                         switch (rightId){
1258                                 case T_char :   return Constant.fromValue(left.intValue() % right.charValue()) ;
1259                                 case T_float:   return Constant.fromValue(left.intValue() % right.floatValue()) ;
1260                                 case T_double:  return Constant.fromValue(left.intValue() % right.doubleValue()) ;
1261                                 case T_byte:    return Constant.fromValue(left.intValue() % right.byteValue()) ;
1262                                 case T_short:   return Constant.fromValue(left.intValue() % right.shortValue()) ;
1263                                 case T_int:             return Constant.fromValue(left.intValue() % right.intValue()) ;
1264                                 case T_long:    return Constant.fromValue(left.intValue() % right.longValue()) ;}
1265                 break;
1266                 case T_long :
1267                         switch (rightId){
1268                                 case T_char :   return Constant.fromValue(left.longValue() % right.charValue()) ;
1269                                 case T_float:   return Constant.fromValue(left.longValue() % right.floatValue()) ;
1270                                 case T_double:  return Constant.fromValue(left.longValue() % right.doubleValue()) ;
1271                                 case T_byte:    return Constant.fromValue(left.longValue() % right.byteValue()) ;
1272                                 case T_short:   return Constant.fromValue(left.longValue() % right.shortValue()) ;
1273                                 case T_int:             return Constant.fromValue(left.longValue() % right.intValue()) ;
1274                                 case T_long:    return Constant.fromValue(left.longValue() % right.longValue()) ;}
1275
1276                 }
1277
1278         return NotAConstant ;}  //should not get here
1279 public static final Constant computeConstantOperationRIGHT_SHIFT(Constant left, int leftId, int operator, Constant right, int rightId) {
1280         //this method  assumes that the TC has been done .
1281
1282         switch (leftId){
1283                 case T_char :
1284                         switch (rightId){
1285                                 case T_char :   return Constant.fromValue(left.charValue() >> right.charValue()) ;
1286                                 case T_byte:    return Constant.fromValue(left.charValue() >> right.byteValue()) ;
1287                                 case T_short:   return Constant.fromValue(left.charValue() >> right.shortValue()) ;
1288                                 case T_int:             return Constant.fromValue(left.charValue() >> right.intValue()) ;
1289                                 case T_long:    return Constant.fromValue(left.charValue() >> right.longValue()) ;}
1290                 break ;
1291                 case T_byte :
1292                         switch (rightId){
1293                                 case T_char :   return Constant.fromValue(left.byteValue() >> right.charValue()) ;
1294                                 case T_byte:    return Constant.fromValue(left.byteValue() >> right.byteValue()) ;
1295                                 case T_short:   return Constant.fromValue(left.byteValue() >> right.shortValue()) ;
1296                                 case T_int:             return Constant.fromValue(left.byteValue() >> right.intValue()) ;
1297                                 case T_long:    return Constant.fromValue(left.byteValue() >> right.longValue()) ;}
1298                 break;
1299                 case T_short :
1300                         switch (rightId){
1301                                 case T_char :   return Constant.fromValue(left.shortValue() >> right.charValue()) ;
1302                                 case T_byte:    return Constant.fromValue(left.shortValue() >> right.byteValue()) ;
1303                                 case T_short:   return Constant.fromValue(left.shortValue() >> right.shortValue()) ;
1304                                 case T_int:             return Constant.fromValue(left.shortValue() >> right.intValue()) ;
1305                                 case T_long:    return Constant.fromValue(left.shortValue() >> right.longValue()) ;}
1306                 break;
1307                 case T_int :
1308                         switch (rightId){
1309                                 case T_char :   return Constant.fromValue(left.intValue() >> right.charValue()) ;
1310                                 case T_byte:    return Constant.fromValue(left.intValue() >> right.byteValue()) ;
1311                                 case T_short:   return Constant.fromValue(left.intValue() >> right.shortValue()) ;
1312                                 case T_int:             return Constant.fromValue(left.intValue() >> right.intValue()) ;
1313                                 case T_long:    return Constant.fromValue(left.intValue() >> right.longValue()) ;}
1314                 break;
1315                 case T_long :
1316                         switch (rightId){
1317                                 case T_char :   return Constant.fromValue(left.longValue() >> right.charValue()) ;
1318                                 case T_byte:    return Constant.fromValue(left.longValue() >> right.byteValue()) ;
1319                                 case T_short:   return Constant.fromValue(left.longValue() >> right.shortValue()) ;
1320                                 case T_int:             return Constant.fromValue(left.longValue() >> right.intValue()) ;
1321                                 case T_long:    return Constant.fromValue(left.longValue() >> right.longValue()) ;}
1322
1323                 }
1324
1325
1326         return NotAConstant ;}  // should not get here
1327 public static final Constant computeConstantOperationUNSIGNED_RIGHT_SHIFT(Constant left, int leftId, int operator, Constant right, int rightId) {
1328         //this method  assumes that the TC has been done .
1329
1330         switch (leftId){
1331                 case T_char :
1332                         switch (rightId){
1333                                 case T_char :   return Constant.fromValue(left.charValue() >>> right.charValue()) ;
1334                                 case T_byte:    return Constant.fromValue(left.charValue() >>> right.byteValue()) ;
1335                                 case T_short:   return Constant.fromValue(left.charValue() >>> right.shortValue()) ;
1336                                 case T_int:             return Constant.fromValue(left.charValue() >>> right.intValue()) ;
1337                                 case T_long:    return Constant.fromValue(left.charValue() >>> right.longValue()) ;}
1338                 break ;
1339                 case T_byte :
1340                         switch (rightId){
1341                                 case T_char :   return Constant.fromValue(left.byteValue() >>> right.charValue()) ;
1342                                 case T_byte:    return Constant.fromValue(left.byteValue() >>> right.byteValue()) ;
1343                                 case T_short:   return Constant.fromValue(left.byteValue() >>> right.shortValue()) ;
1344                                 case T_int:             return Constant.fromValue(left.byteValue() >>> right.intValue()) ;
1345                                 case T_long:    return Constant.fromValue(left.byteValue() >>> right.longValue()) ;}
1346                 break;
1347                 case T_short :
1348                         switch (rightId){
1349                                 case T_char :   return Constant.fromValue(left.shortValue() >>> right.charValue()) ;
1350                                 case T_byte:    return Constant.fromValue(left.shortValue() >>> right.byteValue()) ;
1351                                 case T_short:   return Constant.fromValue(left.shortValue() >>> right.shortValue()) ;
1352                                 case T_int:             return Constant.fromValue(left.shortValue() >>> right.intValue()) ;
1353                                 case T_long:    return Constant.fromValue(left.shortValue() >>> right.longValue()) ;}
1354                 break;
1355                 case T_int :
1356                         switch (rightId){
1357                                 case T_char :   return Constant.fromValue(left.intValue() >>> right.charValue()) ;
1358                                 case T_byte:    return Constant.fromValue(left.intValue() >>> right.byteValue()) ;
1359                                 case T_short:   return Constant.fromValue(left.intValue() >>> right.shortValue()) ;
1360                                 case T_int:             return Constant.fromValue(left.intValue() >>> right.intValue()) ;
1361                                 case T_long:    return Constant.fromValue(left.intValue() >>> right.longValue()) ;}
1362                 break;
1363                 case T_long :
1364                         switch (rightId){
1365                                 case T_char :   return Constant.fromValue(left.longValue() >>> right.charValue()) ;
1366                                 case T_byte:    return Constant.fromValue(left.longValue() >>> right.byteValue()) ;
1367                                 case T_short:   return Constant.fromValue(left.longValue() >>> right.shortValue()) ;
1368                                 case T_int:             return Constant.fromValue(left.longValue() >>> right.intValue()) ;
1369                                 case T_long:    return Constant.fromValue(left.longValue() >>> right.longValue()) ;}
1370
1371                 }
1372
1373
1374         return NotAConstant ;}  // should not get here
1375 public static final Constant computeConstantOperationXOR(Constant left, int leftId, int operator, Constant right, int rightId) {
1376         //this method  assumes that the TC has been done .
1377
1378         switch (leftId){
1379                 case T_boolean :                return Constant.fromValue(left.booleanValue() ^ right.booleanValue()) ;
1380                 case T_char :
1381                         switch (rightId){
1382                                 case T_char :   return Constant.fromValue(left.charValue() ^ right.charValue()) ;
1383                                 case T_byte:    return Constant.fromValue(left.charValue() ^ right.byteValue()) ;
1384                                 case T_short:   return Constant.fromValue(left.charValue() ^ right.shortValue()) ;
1385                                 case T_int:             return Constant.fromValue(left.charValue() ^ right.intValue()) ;
1386                                 case T_long:    return Constant.fromValue(left.charValue() ^ right.longValue()) ;}
1387                 break ;
1388                 case T_byte :
1389                         switch (rightId){
1390                                 case T_char :   return Constant.fromValue(left.byteValue() ^ right.charValue()) ;
1391                                 case T_byte:    return Constant.fromValue(left.byteValue() ^ right.byteValue()) ;
1392                                 case T_short:   return Constant.fromValue(left.byteValue() ^ right.shortValue()) ;
1393                                 case T_int:             return Constant.fromValue(left.byteValue() ^ right.intValue()) ;
1394                                 case T_long:    return Constant.fromValue(left.byteValue() ^ right.longValue()) ;}
1395                 break;
1396                 case T_short :
1397                         switch (rightId){
1398                                 case T_char :   return Constant.fromValue(left.shortValue() ^ right.charValue()) ;
1399                                 case T_byte:    return Constant.fromValue(left.shortValue() ^ right.byteValue()) ;
1400                                 case T_short:   return Constant.fromValue(left.shortValue() ^ right.shortValue()) ;
1401                                 case T_int:             return Constant.fromValue(left.shortValue() ^ right.intValue()) ;
1402                                 case T_long:    return Constant.fromValue(left.shortValue() ^ right.longValue()) ;}
1403                 break;
1404                 case T_int :
1405                         switch (rightId){
1406                                 case T_char :   return Constant.fromValue(left.intValue() ^ right.charValue()) ;
1407                                 case T_byte:    return Constant.fromValue(left.intValue() ^ right.byteValue()) ;
1408                                 case T_short:   return Constant.fromValue(left.intValue() ^ right.shortValue()) ;
1409                                 case T_int:             return Constant.fromValue(left.intValue() ^ right.intValue()) ;
1410                                 case T_long:    return Constant.fromValue(left.intValue() ^ right.longValue()) ;}
1411                 break;
1412                 case T_long :
1413                         switch (rightId){
1414                                 case T_char :   return Constant.fromValue(left.longValue() ^ right.charValue()) ;
1415                                 case T_byte:    return Constant.fromValue(left.longValue() ^ right.byteValue()) ;
1416                                 case T_short:   return Constant.fromValue(left.longValue() ^ right.shortValue()) ;
1417                                 case T_int:             return Constant.fromValue(left.longValue() ^ right.intValue()) ;
1418                                 case T_long:    return Constant.fromValue(left.longValue() ^ right.longValue()) ;}
1419
1420                 }
1421
1422
1423         return NotAConstant ;}  // should not get here
1424 public double doubleValue() {
1425         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"double")); //$NON-NLS-2$ //$NON-NLS-1$
1426 }
1427 public float floatValue() {
1428         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"float")); //$NON-NLS-2$ //$NON-NLS-1$
1429 }
1430 public static Constant fromValue(byte value) {
1431         return new ByteConstant(value);
1432 }
1433 public static Constant fromValue(char value) {
1434         return new CharConstant(value);
1435 }
1436 public static Constant fromValue(double value) {
1437         return new DoubleConstant(value);
1438 }
1439 public static Constant fromValue(float value) {
1440         return new FloatConstant(value);
1441 }
1442 public static Constant fromValue(int value) {
1443         return new IntConstant(value);
1444 }
1445 public static Constant fromValue(long value) {
1446         return new LongConstant(value);
1447 }
1448 public static Constant fromValue(String value) {
1449         if (value == null) return NullConstant.Default;
1450         return new StringConstant(value);
1451 }
1452 public static Constant fromValue(short value) {
1453         return new ShortConstant(value);
1454 }
1455 public static Constant fromValue(boolean value) {
1456         return new BooleanConstant(value);
1457 }
1458 public int intValue() {
1459         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"int")); //$NON-NLS-2$ //$NON-NLS-1$
1460 }
1461 public long longValue() {
1462         throw new ShouldNotImplement(Util.bind("constant.cannotCastedInto",typeName(),"long")); //$NON-NLS-2$ //$NON-NLS-1$
1463 }
1464 public short shortValue() {
1465         throw new ShouldNotImplement(Util.bind("constant.cannotConvertedTo",typeName(),"short")); //$NON-NLS-2$ //$NON-NLS-1$
1466 }
1467 /** Deprecated
1468 */
1469 public String stringValue() {
1470         throw new ShouldNotImplement(Util.bind("constant.cannotConvertedTo",typeName(),"String")); //$NON-NLS-1$ //$NON-NLS-2$
1471 }
1472 public String toString(){
1473
1474         if (this == NotAConstant) return "(Constant) NotAConstant" ; //$NON-NLS-1$
1475         return super.toString(); }
1476 public abstract int typeID();
1477 public String typeName() {
1478         switch (typeID()) {
1479                 case T_int : return "int"; //$NON-NLS-1$
1480                 case T_byte : return "byte"; //$NON-NLS-1$
1481                 case T_short : return "short"; //$NON-NLS-1$
1482                 case T_char : return "char"; //$NON-NLS-1$
1483                 case T_float : return "float"; //$NON-NLS-1$
1484                 case T_double : return "double"; //$NON-NLS-1$
1485                 case T_boolean : return "boolean"; //$NON-NLS-1$
1486                 case T_long : return "long";//$NON-NLS-1$
1487                 case T_String : return "java.lang.String"; //$NON-NLS-1$
1488                 case T_null : return "null";     //$NON-NLS-1$
1489                 default: return "unknown"; //$NON-NLS-1$
1490         }
1491 }
1492 }