import eclipse 3.1 M4 compiler
[org.ibex.tool.git] / src / org / eclipse / jdt / internal / compiler / ast / OperatorExpression.java
index 4574e0b..7ea85eb 100644 (file)
@@ -10,6 +10,8 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.ast;
 
+import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
+
 public abstract class OperatorExpression extends Expression implements OperatorIds {
 
        public static int[][] OperatorSignatures = new int[NumberOfTables][];
@@ -66,10 +68,10 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                                        case T_float    : return "100.0f"; //$NON-NLS-1$
                                        case T_int              : return "1"; //$NON-NLS-1$
                                        case T_long             : return "7L"; //$NON-NLS-1$
-                                       case T_String   : return "\"hello-world\""; //$NON-NLS-1$
+                                       case T_JavaLangString   : return "\"hello-world\""; //$NON-NLS-1$
                                        case T_null             : return "null"; //$NON-NLS-1$
                                        case T_short    : return "((short) 5)"; //$NON-NLS-1$
-                                       case T_Object   : return "null";} //$NON-NLS-1$
+                                       case T_JavaLangObject   : return "null";} //$NON-NLS-1$
                                return "";} //$NON-NLS-1$
        
                        public  final String type(int code){
@@ -81,10 +83,10 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                                        case T_float    : return "f"; //$NON-NLS-1$
                                        case T_int              : return "i"; //$NON-NLS-1$
                                        case T_long             : return "l"; //$NON-NLS-1$
-                                       case T_String   : return "str"; //$NON-NLS-1$
+                                       case T_JavaLangString   : return "str"; //$NON-NLS-1$
                                        case T_null             : return "null"; //$NON-NLS-1$
                                        case T_short    : return "s"; //$NON-NLS-1$
-                                       case T_Object   : return "obj";} //$NON-NLS-1$
+                                       case T_JavaLangObject   : return "obj";} //$NON-NLS-1$
                                return "xxx";} //$NON-NLS-1$
                        
                        public  final String operator(int operator){
@@ -122,7 +124,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                        "\t\t//method automatically generated by\n"+ //$NON-NLS-1$
                        "\t\t//org.eclipse.jdt.internal.compiler.ast.OperatorExpression.generateTableTestCase();\n"+ //$NON-NLS-1$
                
-                       "\t\tString str0;\t String str\t= "+decode.constant(T_String)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
+                       "\t\tString str0;\t String str\t= "+decode.constant(T_JavaLangString)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
                        "\t\tint i0;\t int i\t= "+decode.constant(T_int)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
                        "\t\tboolean z0;\t boolean z\t= "+decode.constant(T_boolean)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
                        "\t\tchar c0; \t char  c\t= "+decode.constant(T_char)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
@@ -131,7 +133,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                        "\t\tbyte b0; \t byte b\t= "+decode.constant(T_byte)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
                        "\t\tshort s0; \t short s\t= "+decode.constant(T_short)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
                        "\t\tlong l0; \t long l\t= "+decode.constant(T_long)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
-                       "\t\tObject obj0; \t Object obj\t= "+decode.constant(T_Object)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
+                       "\t\tObject obj0; \t Object obj\t= "+decode.constant(T_JavaLangObject)+";\n"+ //$NON-NLS-1$ //$NON-NLS-2$
                        "\n"; //$NON-NLS-1$
        
                int error = 0;          
@@ -150,8 +152,8 @@ public abstract class OperatorExpression extends Expression implements OperatorI
        
                                {       s += "\t\t"+decode.type(result)+"0"+" = "+decode.type(left); //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$
                                        s += " "+decode.operator(operator)+" "+decode.type(right)+";\n"; //$NON-NLS-2$ //$NON-NLS-1$ //$NON-NLS-3$
-                                       String begin = result == T_String ? "\t\tif (! " : "\t\tif ( "; //$NON-NLS-2$ //$NON-NLS-1$
-                                       String test = result == T_String ? ".equals(" : " != ("; //$NON-NLS-2$ //$NON-NLS-1$
+                                       String begin = result == T_JavaLangString ? "\t\tif (! " : "\t\tif ( "; //$NON-NLS-2$ //$NON-NLS-1$
+                                       String test = result == T_JavaLangString ? ".equals(" : " != ("; //$NON-NLS-2$ //$NON-NLS-1$
                                        s += begin      +decode.type(result)+"0"+test //$NON-NLS-1$
                                                                +decode.constant(left)+" " //$NON-NLS-1$
                                                                +decode.operator(operator)+" " //$NON-NLS-1$
@@ -167,7 +169,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
 
        public static final int[] get_AND(){
        
-               //the code is an int
+               //the code is an int, only 20 bits are used, see below.
                // (cast)  left   Op (cast)  rigth --> result
                //  0000   0000       0000   0000      0000
                //  <<16   <<12       <<8    <<4       
@@ -649,34 +651,34 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                //      table[(T_String<<4)+T_long]             = T_undefined; 
                //      table[(T_String<<4)+T_short]            = T_undefined;
                //      table[(T_String<<4)+T_void]             = T_undefined;
-               table[(T_String<<4)+T_String]           = /*String2Object                 String2Object*/
-                                                                                         (T_Object<<16)+(T_String<<12)+(T_Object<<8)+(T_String<<4)+T_boolean;
-               table[(T_String<<4)+T_Object]           = /*String2Object                 Object2Object*/
-                                                                                         (T_Object<<16)+(T_String<<12)+(T_Object<<8)+(T_Object<<4)+T_boolean;
+               table[(T_JavaLangString<<4)+T_JavaLangString]           = /*String2Object                 String2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_JavaLangString<<12)+(T_JavaLangObject<<8)+(T_JavaLangString<<4)+T_boolean;
+               table[(T_JavaLangString<<4)+T_JavaLangObject]           = /*String2Object                 Object2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_JavaLangString<<12)+(T_JavaLangObject<<8)+(T_JavaLangObject<<4)+T_boolean;
                //      table[(T_String<<4)+T_double]           = T_undefined;
                //      table[(T_String<<4)+T_float]            = T_undefined; 
                //      table[(T_String<<4)+T_boolean]          = T_undefined;
                //      table[(T_String<<4)+T_char]             = T_undefined;
                //      table[(T_String<<4)+T_int]                      = T_undefined;
-               table[(T_String<<4)+T_null]             = /*Object2String                null2Object */
-                                                                                         (T_Object<<16)+(T_String<<12)+(T_Object<<8)+(T_null<<4)+T_boolean;
+               table[(T_JavaLangString<<4)+T_null]             = /*Object2String                null2Object */
+                                                                                         (T_JavaLangObject<<16)+(T_JavaLangString<<12)+(T_JavaLangObject<<8)+(T_null<<4)+T_boolean;
        
                //      table[(T_Object<<4)+T_undefined]        = T_undefined;
                //      table[(T_Object<<4)+T_byte]             = T_undefined;
                //      table[(T_Object<<4)+T_long]             = T_undefined;
                //      table[(T_Object<<4)+T_short]            = T_undefined;
                //      table[(T_Object<<4)+T_void]             = T_undefined;
-               table[(T_Object<<4)+T_String]           = /*Object2Object                 String2Object*/
-                                                                                         (T_Object<<16)+(T_Object<<12)+(T_Object<<8)+(T_String<<4)+T_boolean;
-               table[(T_Object<<4)+T_Object]           = /*Object2Object                 Object2Object*/
-                                                                                         (T_Object<<16)+(T_Object<<12)+(T_Object<<8)+(T_Object<<4)+T_boolean;
+               table[(T_JavaLangObject<<4)+T_JavaLangString]           = /*Object2Object                 String2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_JavaLangObject<<12)+(T_JavaLangObject<<8)+(T_JavaLangString<<4)+T_boolean;
+               table[(T_JavaLangObject<<4)+T_JavaLangObject]           = /*Object2Object                 Object2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_JavaLangObject<<12)+(T_JavaLangObject<<8)+(T_JavaLangObject<<4)+T_boolean;
                //      table[(T_Object<<4)+T_double]           = T_undefined;
                //      table[(T_Object<<4)+T_float]            = T_undefined;
                //      table[(T_Object<<4)+T_boolean]          = T_undefined;
                //      table[(T_Object<<4)+T_char]             = T_undefined;
                //      table[(T_Object<<4)+T_int]                      = T_undefined;
-               table[(T_Object<<4)+T_null]             = /*Object2Object                 null2Object*/
-                                                                                         (T_Object<<16)+(T_Object<<12)+(T_Object<<8)+(T_null<<4)+T_boolean;
+               table[(T_JavaLangObject<<4)+T_null]             = /*Object2Object                 null2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_JavaLangObject<<12)+(T_JavaLangObject<<8)+(T_null<<4)+T_boolean;
        
                //      table[(T_double<<4)+T_undefined]        = T_undefined;
                table[(T_double<<4)+T_byte]             = (Double2Double<<12)+(Byte2Double<<4)+T_boolean;
@@ -753,17 +755,17 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                //      table[(T_null<<4)+T_long]                       = T_undefined;
                //      table[(T_null<<4)+T_short]                      = T_undefined;
                //      table[(T_null<<4)+T_void]                       = T_undefined;
-               table[(T_null<<4)+T_String]             = /*null2Object                 String2Object*/
-                                                                                         (T_Object<<16)+(T_null<<12)+(T_Object<<8)+(T_String<<4)+T_boolean;
-               table[(T_null<<4)+T_Object]             = /*null2Object                 Object2Object*/
-                                                                                         (T_Object<<16)+(T_null<<12)+(T_Object<<8)+(T_Object<<4)+T_boolean; 
+               table[(T_null<<4)+T_JavaLangString]             = /*null2Object                 String2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_null<<12)+(T_JavaLangObject<<8)+(T_JavaLangString<<4)+T_boolean;
+               table[(T_null<<4)+T_JavaLangObject]             = /*null2Object                 Object2Object*/
+                                                                                         (T_JavaLangObject<<16)+(T_null<<12)+(T_JavaLangObject<<8)+(T_JavaLangObject<<4)+T_boolean; 
                //      table[(T_null<<4)+T_double]             = T_undefined;
                //      table[(T_null<<4)+T_float]                      = T_undefined;
                //      table[(T_null<<4)+T_boolean]            = T_undefined;
                //      table[(T_null<<4)+T_char]                       = T_undefined;
                //      table[(T_null<<4)+T_int]                        = T_undefined;
                table[(T_null<<4)+T_null]                       = /*null2Object                 null2Object*/
-                                                                                         (T_Object<<16)+(T_null<<12)+(T_Object<<8)+(T_null<<4)+T_boolean;
+                                                                                         (T_JavaLangObject<<16)+(T_null<<12)+(T_JavaLangObject<<8)+(T_null<<4)+T_boolean;
                return table;
        }
 
@@ -1200,30 +1202,30 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table = (int[]) get_PLUS().clone();
 
                // customization        
-               table[(T_String<<4)+T_byte]             = T_undefined;
-               table[(T_String<<4)+T_long]             = T_undefined;
-               table[(T_String<<4)+T_short]            = T_undefined;
-               table[(T_String<<4)+T_void]             = T_undefined;
-               table[(T_String<<4)+T_String]           = T_undefined;
-               table[(T_String<<4)+T_Object]           = T_undefined;
-               table[(T_String<<4)+T_double]           = T_undefined;
-               table[(T_String<<4)+T_float]            = T_undefined;
-               table[(T_String<<4)+T_boolean]          = T_undefined;
-               table[(T_String<<4)+T_char]             = T_undefined;
-               table[(T_String<<4)+T_int]                      = T_undefined;
-               table[(T_String<<4)+T_null]             = T_undefined;
-               
-               table[(T_byte<<4)       +T_String]              = T_undefined;
-               table[(T_long<<4)       +T_String]              = T_undefined;
-               table[(T_short<<4)      +T_String]              = T_undefined;
-               table[(T_void<<4)       +T_String]              = T_undefined;
-               table[(T_Object<<4)     +T_String]              = T_undefined;
-               table[(T_double<<4)     +T_String]              = T_undefined;
-               table[(T_float<<4)      +T_String]              = T_undefined;
-               table[(T_boolean<<4)+T_String]          = T_undefined;
-               table[(T_char<<4)       +T_String]              = T_undefined;
-               table[(T_int<<4)        +T_String]              = T_undefined;
-               table[(T_null<<4)       +T_String]              = T_undefined;
+               table[(T_JavaLangString<<4)+T_byte]             = T_undefined;
+               table[(T_JavaLangString<<4)+T_long]             = T_undefined;
+               table[(T_JavaLangString<<4)+T_short]            = T_undefined;
+               table[(T_JavaLangString<<4)+T_void]             = T_undefined;
+               table[(T_JavaLangString<<4)+T_JavaLangString]           = T_undefined;
+               table[(T_JavaLangString<<4)+T_JavaLangObject]           = T_undefined;
+               table[(T_JavaLangString<<4)+T_double]           = T_undefined;
+               table[(T_JavaLangString<<4)+T_float]            = T_undefined;
+               table[(T_JavaLangString<<4)+T_boolean]          = T_undefined;
+               table[(T_JavaLangString<<4)+T_char]             = T_undefined;
+               table[(T_JavaLangString<<4)+T_int]                      = T_undefined;
+               table[(T_JavaLangString<<4)+T_null]             = T_undefined;
+               
+               table[(T_byte<<4)       +T_JavaLangString]              = T_undefined;
+               table[(T_long<<4)       +T_JavaLangString]              = T_undefined;
+               table[(T_short<<4)      +T_JavaLangString]              = T_undefined;
+               table[(T_void<<4)       +T_JavaLangString]              = T_undefined;
+               table[(T_JavaLangObject<<4)     +T_JavaLangString]              = T_undefined;
+               table[(T_double<<4)     +T_JavaLangString]              = T_undefined;
+               table[(T_float<<4)      +T_JavaLangString]              = T_undefined;
+               table[(T_boolean<<4)+T_JavaLangString]          = T_undefined;
+               table[(T_char<<4)       +T_JavaLangString]              = T_undefined;
+               table[(T_int<<4)        +T_JavaLangString]              = T_undefined;
+               table[(T_null<<4)       +T_JavaLangString]              = T_undefined;
                
                table[(T_null<<4)       +T_null]                = T_undefined;
        
@@ -1292,7 +1294,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_byte<<4)+T_long]               = (Byte2Long<<12)+(Long2Long<<4)+T_long;
                table[(T_byte<<4)+T_short]              = (Byte2Int<<12)+(Short2Int<<4)+T_int;
                //      table[(T_byte<<4)+T_void]               = T_undefined;
-               table[(T_byte<<4)+T_String]     = (Byte2Byte<<12)+(String2String<<4)+T_String;
+               table[(T_byte<<4)+T_JavaLangString]     = (Byte2Byte<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_byte<<4)+T_Object]     = T_undefined;
                table[(T_byte<<4)+T_double]     = (Byte2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_byte<<4)+T_float]              = (Byte2Float<<12)+(Float2Float<<4)+T_float;
@@ -1306,7 +1308,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_long<<4)+T_long]               = (Long2Long<<12)+(Long2Long<<4)+T_long;
                table[(T_long<<4)+T_short]              = (Long2Long<<12)+(Short2Long<<4)+T_long;
                //      table[(T_long<<4)+T_void]               = T_undefined;
-               table[(T_long<<4)+T_String]     = (Long2Long<<12)+(String2String<<4)+T_String;
+               table[(T_long<<4)+T_JavaLangString]     = (Long2Long<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_long<<4)+T_Object]     = T_undefined;
                table[(T_long<<4)+T_double]     = (Long2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_long<<4)+T_float]              = (Long2Float<<12)+(Float2Float<<4)+T_float;
@@ -1320,7 +1322,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_short<<4)+T_long]                      = (Short2Long<<12)+(Long2Long<<4)+T_long;
                table[(T_short<<4)+T_short]             = (Short2Int<<12)+(Short2Int<<4)+T_int;
                //      table[(T_short<<4)+T_void]                      = T_undefined;
-               table[(T_short<<4)+T_String]            = (Short2Short<<12)+(String2String<<4)+T_String;
+               table[(T_short<<4)+T_JavaLangString]            = (Short2Short<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_short<<4)+T_Object]            = T_undefined;
                table[(T_short<<4)+T_double]            = (Short2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_short<<4)+T_float]             = (Short2Float<<12)+(Float2Float<<4)+T_float;
@@ -1344,25 +1346,25 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                //      table[(T_void<<4)+T_null]               = T_undefined;
                
                //      table[(T_String<<4)+T_undefined]        = T_undefined; 
-               table[(T_String<<4)+T_byte]             = (String2String<<12)+(Byte2Byte<<4)+T_String;
-               table[(T_String<<4)+T_long]             = (String2String<<12)+(Long2Long<<4)+T_String; 
-               table[(T_String<<4)+T_short]            = (String2String<<12)+(Short2Short<<4)+T_String;
+               table[(T_JavaLangString<<4)+T_byte]             = (String2String<<12)+(Byte2Byte<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_long]             = (String2String<<12)+(Long2Long<<4)+T_JavaLangString; 
+               table[(T_JavaLangString<<4)+T_short]            = (String2String<<12)+(Short2Short<<4)+T_JavaLangString;
                //      table[(T_String<<4)+T_void]             = T_undefined;
-               table[(T_String<<4)+T_String]           = (String2String<<12)+(String2String<<4)+T_String;
-               table[(T_String<<4)+T_Object]           = (String2String<<12)+(Object2Object<<4)+T_String;
-               table[(T_String<<4)+T_double]           = (String2String<<12)+(Double2Double<<4)+T_String;
-               table[(T_String<<4)+T_float]            = (String2String<<12)+(Float2Float<<4)+T_String; 
-               table[(T_String<<4)+T_boolean]          = (String2String<<12)+(Boolean2Boolean<<4)+T_String;
-               table[(T_String<<4)+T_char]             = (String2String<<12)+(Char2Char<<4)+T_String;
-               table[(T_String<<4)+T_int]                      = (String2String<<12)+(Int2Int<<4)+T_String;
-               table[(T_String<<4)+T_null]             = (String2String<<12)+(T_null<<8)+(T_null<<4)+T_String;
+               table[(T_JavaLangString<<4)+T_JavaLangString]           = (String2String<<12)+(String2String<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_JavaLangObject]           = (String2String<<12)+(Object2Object<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_double]           = (String2String<<12)+(Double2Double<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_float]            = (String2String<<12)+(Float2Float<<4)+T_JavaLangString; 
+               table[(T_JavaLangString<<4)+T_boolean]          = (String2String<<12)+(Boolean2Boolean<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_char]             = (String2String<<12)+(Char2Char<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_int]                      = (String2String<<12)+(Int2Int<<4)+T_JavaLangString;
+               table[(T_JavaLangString<<4)+T_null]             = (String2String<<12)+(T_null<<8)+(T_null<<4)+T_JavaLangString;
        
                //      table[(T_Object<<4)+T_undefined]        = T_undefined;
                //      table[(T_Object<<4)+T_byte]             = T_undefined;
                //      table[(T_Object<<4)+T_long]             = T_undefined;
                //      table[(T_Object<<4)+T_short]            = T_undefined;
                //      table[(T_Object<<4)+T_void]             = T_undefined;
-               table[(T_Object<<4)+T_String]           = (Object2Object<<12)+(String2String<<4)+T_String;
+               table[(T_JavaLangObject<<4)+T_JavaLangString]           = (Object2Object<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_Object<<4)+T_Object]           = T_undefined;
                //      table[(T_Object<<4)+T_double]           = T_undefined;
                //      table[(T_Object<<4)+T_float]            = T_undefined;
@@ -1376,7 +1378,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_double<<4)+T_long]             = (Double2Double<<12)+(Long2Double<<4)+T_double;
                table[(T_double<<4)+T_short]            = (Double2Double<<12)+(Short2Double<<4)+T_double; 
                //      table[(T_double<<4)+T_void]             = T_undefined;
-               table[(T_double<<4)+T_String]           = (Double2Double<<12)+(String2String<<4)+T_String;
+               table[(T_double<<4)+T_JavaLangString]           = (Double2Double<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_double<<4)+T_Object]           = T_undefined;
                table[(T_double<<4)+T_double]           = (Double2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_double<<4)+T_float]            = (Double2Double<<12)+(Float2Double<<4)+T_double; 
@@ -1390,7 +1392,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_float<<4)+T_long]                      = (Float2Float<<12)+(Long2Float<<4)+T_float;
                table[(T_float<<4)+T_short]             = (Float2Float<<12)+(Short2Float<<4)+T_float;
                //      table[(T_float<<4)+T_void]                      = T_undefined;
-               table[(T_float<<4)+T_String]            = (Float2Float<<12)+(String2String<<4)+T_String;
+               table[(T_float<<4)+T_JavaLangString]            = (Float2Float<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_float<<4)+T_Object]            = T_undefined;
                table[(T_float<<4)+T_double]            = (Float2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_float<<4)+T_float]             = (Float2Float<<12)+(Float2Float<<4)+T_float;
@@ -1404,7 +1406,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                //      table[(T_boolean<<4)+T_long]                    = T_undefined;
                //      table[(T_boolean<<4)+T_short]                   = T_undefined;
                //      table[(T_boolean<<4)+T_void]                    = T_undefined;
-               table[(T_boolean<<4)+T_String]                  = (Boolean2Boolean<<12)+(String2String<<4)+T_String;
+               table[(T_boolean<<4)+T_JavaLangString]                  = (Boolean2Boolean<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_boolean<<4)+T_Object]                  = T_undefined;
                //      table[(T_boolean<<4)+T_double]                  = T_undefined;
                //      table[(T_boolean<<4)+T_float]                   = T_undefined;
@@ -1418,7 +1420,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_char<<4)+T_long]                       = (Char2Long<<12)+(Long2Long<<4)+T_long;
                table[(T_char<<4)+T_short]                      = (Char2Int<<12)+(Short2Int<<4)+T_int;
                //      table[(T_char<<4)+T_void]                       = T_undefined;
-               table[(T_char<<4)+T_String]             = (Char2Char<<12)+(String2String<<4)+T_String;
+               table[(T_char<<4)+T_JavaLangString]             = (Char2Char<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_char<<4)+T_Object]             = T_undefined;
                table[(T_char<<4)+T_double]             = (Char2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_char<<4)+T_float]                      = (Char2Float<<12)+(Float2Float<<4)+T_float;
@@ -1432,7 +1434,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                table[(T_int<<4)+T_long]                = (Int2Long<<12)+(Long2Long<<4)+T_long;
                table[(T_int<<4)+T_short]               = (Int2Int<<12)+(Short2Int<<4)+T_int;
                //      table[(T_int<<4)+T_void]                = T_undefined;
-               table[(T_int<<4)+T_String]              = (Int2Int<<12)+(String2String<<4)+T_String;
+               table[(T_int<<4)+T_JavaLangString]              = (Int2Int<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_int<<4)+T_Object]              = T_undefined;
                table[(T_int<<4)+T_double]              = (Int2Double<<12)+(Double2Double<<4)+T_double;
                table[(T_int<<4)+T_float]               = (Int2Float<<12)+(Float2Float<<4)+T_float;
@@ -1446,7 +1448,7 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                //      table[(T_null<<4)+T_long]                       = T_undefined;
                //      table[(T_null<<4)+T_short]                      = T_undefined;
                //      table[(T_null<<4)+T_void]                       = T_undefined;
-               table[(T_null<<4)+T_String]             = (T_null<<16)+(T_null<<12)+(String2String<<4)+T_String;
+               table[(T_null<<4)+T_JavaLangString]             = (T_null<<16)+(T_null<<12)+(String2String<<4)+T_JavaLangString;
                //      table[(T_null<<4)+T_Object]             = T_undefined;
                //      table[(T_null<<4)+T_double]             = T_undefined;
                //      table[(T_null<<4)+T_float]                      = T_undefined;
@@ -1554,6 +1556,10 @@ public abstract class OperatorExpression extends Expression implements OperatorI
                return "unknown operator"; //$NON-NLS-1$
        }
 
+       public int nullStatus(FlowInfo flowInfo) {
+               return FlowInfo.UNKNOWN;
+       }
+       
        public StringBuffer printExpression(int indent, StringBuffer output){
 
                output.append('(');