projects / org.ibex.tool.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
import eclipse 3.1 M4 compiler
[org.ibex.tool.git] / src / org / eclipse / jdt / internal / compiler / impl / Constant.java
diff --git a/src/org/eclipse/jdt/internal/compiler/impl/Constant.java b/src/org/eclipse/jdt/internal/compiler/impl/Constant.java
index f82b409..3130eed 100644 (file)
--- a/src/org/eclipse/jdt/internal/compiler/impl/Constant.java
+++ b/src/org/eclipse/jdt/internal/compiler/impl/Constant.java
@@ -112,7 +112,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
        //          case (T_String<<4)+T_long            : return NotAConstant;   
        //          case (T_String<<4)+T_short           : return NotAConstant;   
        //          case (T_String<<4)+T_void            : return NotAConstant;   
-                   case (T_String<<4)+T_String          : return this;   
+                   case (T_JavaLangString<<4)+T_JavaLangString          : return this;   
        //          case (T_String<<4)+T_Object          : return NotAConstant;   
        //          case (T_String<<4)+T_double          : return NotAConstant;   
        //          case (T_String<<4)+T_float           : return NotAConstant;   
@@ -213,7 +213,8 @@ public abstract class Constant implements TypeIds, OperatorIds {
                switch (operator) {
                        case NOT        :       
                                                        return Constant.fromValue(!cst.booleanValue());
-                       case PLUS       :       return cst; 
+                       case PLUS       :
+                                                       return computeConstantOperationPLUS(Zero,T_int,cst,id);
                        case MINUS      :       //the two special -9223372036854775808L and -2147483648 are inlined at parseTime
                                                        switch (id){
                                                                case T_float  : float f;
@@ -233,7 +234,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                                                                                                return Constant.fromValue(0.0d);}
                                                                                                break; //default case
                                                        }
-                                                       return computeConstantOperationMINUS(Zero,T_int,operator,cst,id);
+                                                       return computeConstantOperationMINUS(Zero,T_int,cst,id);
                        case TWIDDLE:   
                                switch (id){
                                        case T_char :   return Constant.fromValue(~ cst.charValue());
@@ -250,29 +251,29 @@ public abstract class Constant implements TypeIds, OperatorIds {
        public static final Constant computeConstantOperation(Constant left, int leftId, int operator, Constant right, int rightId) {
 
                switch (operator) {
-                       case AND                : return computeConstantOperationAND            (left,leftId,operator,right,rightId);
-                       case AND_AND    : return computeConstantOperationAND_AND        (left,leftId,operator,right,rightId);
-                       case DIVIDE     : return computeConstantOperationDIVIDE         (left,leftId,operator,right,rightId);
-                       case GREATER    : return computeConstantOperationGREATER        (left,leftId,operator,right,rightId);
-                       case GREATER_EQUAL      : return computeConstantOperationGREATER_EQUAL(left,leftId,operator,right,rightId);
-                       case LEFT_SHIFT : return computeConstantOperationLEFT_SHIFT     (left,leftId,operator,right,rightId);
-                       case LESS               : return computeConstantOperationLESS           (left,leftId,operator,right,rightId);
-                       case LESS_EQUAL : return computeConstantOperationLESS_EQUAL     (left,leftId,operator,right,rightId);
-                       case MINUS              : return computeConstantOperationMINUS          (left,leftId,operator,right,rightId);
-                       case MULTIPLY   : return computeConstantOperationMULTIPLY       (left,leftId,operator,right,rightId);
-                       case OR                 : return computeConstantOperationOR                     (left,leftId,operator,right,rightId);
-                       case OR_OR              : return computeConstantOperationOR_OR          (left,leftId,operator,right,rightId);
-                       case PLUS               : return computeConstantOperationPLUS           (left,leftId,operator,right,rightId);
-                       case REMAINDER  : return computeConstantOperationREMAINDER      (left,leftId,operator,right,rightId);
-                       case RIGHT_SHIFT: return computeConstantOperationRIGHT_SHIFT(left,leftId,operator,right,rightId);
-                       case UNSIGNED_RIGHT_SHIFT: return computeConstantOperationUNSIGNED_RIGHT_SHIFT(left,leftId,operator,right,rightId);
-                       case XOR                : return computeConstantOperationXOR            (left,leftId,operator,right,rightId);
+                       case AND                : return computeConstantOperationAND            (left,leftId,right,rightId);
+                       case AND_AND    : return computeConstantOperationAND_AND        (left,leftId,right,rightId);
+                       case DIVIDE     : return computeConstantOperationDIVIDE         (left,leftId,right,rightId);
+                       case GREATER    : return computeConstantOperationGREATER        (left,leftId,right,rightId);
+                       case GREATER_EQUAL      : return computeConstantOperationGREATER_EQUAL(left,leftId,right,rightId);
+                       case LEFT_SHIFT : return computeConstantOperationLEFT_SHIFT     (left,leftId,right,rightId);
+                       case LESS               : return computeConstantOperationLESS           (left,leftId,right,rightId);
+                       case LESS_EQUAL : return computeConstantOperationLESS_EQUAL     (left,leftId,right,rightId);
+                       case MINUS              : return computeConstantOperationMINUS          (left,leftId,right,rightId);
+                       case MULTIPLY   : return computeConstantOperationMULTIPLY       (left,leftId,right,rightId);
+                       case OR                 : return computeConstantOperationOR                     (left,leftId,right,rightId);
+                       case OR_OR              : return computeConstantOperationOR_OR          (left,leftId,right,rightId);
+                       case PLUS               : return computeConstantOperationPLUS           (left,leftId,right,rightId);
+                       case REMAINDER  : return computeConstantOperationREMAINDER      (left,leftId,right,rightId);
+                       case RIGHT_SHIFT: return computeConstantOperationRIGHT_SHIFT(left,leftId,right,rightId);
+                       case UNSIGNED_RIGHT_SHIFT: return computeConstantOperationUNSIGNED_RIGHT_SHIFT(left,leftId,right,rightId);
+                       case XOR                : return computeConstantOperationXOR            (left,leftId,right,rightId);
        
                        default : return NotAConstant;
                }
        }
        
-       public static final Constant computeConstantOperationAND(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationAND(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_boolean :                return Constant.fromValue(left.booleanValue() & right.booleanValue());
@@ -325,12 +326,12 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        } 
                
-       public static final Constant computeConstantOperationAND_AND(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationAND_AND(Constant left, int leftId, Constant right, int rightId) {
        
                return Constant.fromValue(left.booleanValue() && right.booleanValue());
        }
                
-       public static final Constant computeConstantOperationDIVIDE(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationDIVIDE(Constant left, int leftId, Constant right, int rightId) {
                // division by zero must be handled outside this method (error reporting)
        
                switch (leftId){
@@ -416,7 +417,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        } 
                
-       public static final Constant computeConstantOperationEQUAL_EQUAL(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationEQUAL_EQUAL(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_boolean :
@@ -500,15 +501,15 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_long:    return Constant.fromValue(left.longValue() == right.longValue());
                                }
                        break;
-                       case T_String :
-                               if (rightId == T_String) {
+                       case T_JavaLangString :
+                               if (rightId == T_JavaLangString) {
                                        //String are interned in th compiler==>thus if two string constant
                                        //get to be compared, it is an equal on the vale which is done
                                        return Constant.fromValue(((StringConstant)left).compileTimeEqual((StringConstant)right));
                                }
                        break;  
                        case T_null :
-                               if (rightId == T_String) { 
+                               if (rightId == T_JavaLangString) { 
                                        return Constant.fromValue(false);
                                } else {
                                        if (rightId == T_null) { 
@@ -520,7 +521,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return Constant.fromValue(false);
        }
                
-       public static final Constant computeConstantOperationGREATER(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationGREATER(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char : 
@@ -605,7 +606,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
 
-       public static final Constant computeConstantOperationGREATER_EQUAL(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationGREATER_EQUAL(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char : 
@@ -690,7 +691,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }  
                
-       public static final Constant computeConstantOperationLEFT_SHIFT(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationLEFT_SHIFT(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char :
@@ -743,7 +744,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        } 
                
-       public static final Constant computeConstantOperationLESS(Constant left, int leftId, int operator, Constant right, int rightId) { 
+       public static final Constant computeConstantOperationLESS(Constant left, int leftId, Constant right, int rightId) { 
                
                switch (leftId){
                        case T_char : 
@@ -828,7 +829,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
                
-       public static final Constant computeConstantOperationLESS_EQUAL(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationLESS_EQUAL(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char : 
@@ -912,7 +913,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }  
        
-       public static final Constant computeConstantOperationMINUS(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationMINUS(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char : 
@@ -997,7 +998,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
        
-       public static final Constant computeConstantOperationMULTIPLY(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationMULTIPLY(Constant left, int leftId, Constant right, int rightId) {
        
                switch (leftId){
                        case T_char :
@@ -1081,7 +1082,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
        
-       public static final Constant computeConstantOperationOR(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationOR(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_boolean :                return Constant.fromValue(left.booleanValue() | right.booleanValue());
@@ -1135,20 +1136,20 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
        
-       public static final Constant computeConstantOperationOR_OR(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationOR_OR(Constant left, int leftId, Constant right, int rightId) {
        
                return Constant.fromValue(left.booleanValue() || right.booleanValue());
        }
                
-       public static final Constant computeConstantOperationPLUS(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationPLUS(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
-                       case T_Object :
-                               if (rightId == T_String) {
+                       case T_JavaLangObject :
+                               if (rightId == T_JavaLangString) {
                                        return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        case T_boolean :
-                               if (rightId == T_String) {
+                               if (rightId == T_JavaLangString) {
                                        return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        break;
@@ -1161,7 +1162,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.charValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.charValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.charValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue());
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        break;
                        case T_float :
@@ -1173,7 +1174,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.floatValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.floatValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.floatValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
                                }
                        break;
                        case T_double :
@@ -1185,7 +1186,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.doubleValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.doubleValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.doubleValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue());
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        break;
                        case T_byte :
@@ -1197,7 +1198,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.byteValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.byteValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.byteValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
                                }
        
                        break;                  
@@ -1210,7 +1211,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.shortValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.shortValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.shortValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue());
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        break;
                        case T_int :
@@ -1222,7 +1223,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.intValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.intValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.intValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue());
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        break;          
                        case T_long :
@@ -1234,10 +1235,10 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.longValue() + right.shortValue());
                                        case T_int:             return Constant.fromValue(left.longValue() + right.intValue());
                                        case T_long:    return Constant.fromValue(left.longValue() + right.longValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
                                }
                        break;
-                       case T_String :
+                       case T_JavaLangString :
                                switch (rightId){
                                        case T_char :   return Constant.fromValue(left.stringValue() + right.stringValue());
                                        case T_float:   return Constant.fromValue(left.stringValue() + right.stringValue());
@@ -1246,7 +1247,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.stringValue() + right.stringValue());
                                        case T_int:             return Constant.fromValue(left.stringValue() + right.stringValue());
                                        case T_long:    return Constant.fromValue(left.stringValue() + right.stringValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
                                        case T_boolean: return Constant.fromValue(left.stringValue() + right.stringValue());
                                }
                        break;  
@@ -1259,7 +1260,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                                        case T_short:   return Constant.fromValue(left.stringValue() + right.stringValue());
                                        case T_int:             return Constant.fromValue(left.stringValue() + right.stringValue());
                                        case T_long:    return Constant.fromValue(left.stringValue() + right.stringValue());
-                                       case T_String:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
+                                       case T_JavaLangString:  return Constant.fromValue(left.stringValue() + right.stringValue()); 
                                }
                                
                        }
@@ -1267,7 +1268,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
                
-       public static final Constant computeConstantOperationREMAINDER(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationREMAINDER(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char : 
@@ -1352,7 +1353,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        } 
        
-       public static final Constant computeConstantOperationRIGHT_SHIFT(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationRIGHT_SHIFT(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char :
@@ -1405,7 +1406,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
 
-       public static final Constant computeConstantOperationUNSIGNED_RIGHT_SHIFT(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationUNSIGNED_RIGHT_SHIFT(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_char :
@@ -1458,7 +1459,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                return NotAConstant;
        }
        
-       public static final Constant computeConstantOperationXOR(Constant left, int leftId, int operator, Constant right, int rightId) {
+       public static final Constant computeConstantOperationXOR(Constant left, int leftId, Constant right, int rightId) {
                
                switch (leftId){
                        case T_boolean :                return Constant.fromValue(left.booleanValue() ^ right.booleanValue());
@@ -1603,7 +1604,7 @@ public abstract class Constant implements TypeIds, OperatorIds {
                        case T_double : return "double"; //$NON-NLS-1$
                        case T_boolean : return "boolean"; //$NON-NLS-1$
                        case T_long : return "long";//$NON-NLS-1$
-                       case T_String : return "java.lang.String"; //$NON-NLS-1$
+                       case T_JavaLangString : return "java.lang.String"; //$NON-NLS-1$
                        case T_null : return "null";     //$NON-NLS-1$
                        default: return "unknown"; //$NON-NLS-1$
                }
Unnamed repository; edit this file to name it for gitweb.