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