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