src/org/eclipse/jdt/internal/compiler/impl/Constant.java

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