0c17dc7def94932f13b85f15213ce875dfd98e73
[phpeclipse.git] /
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 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 net.sourceforge.phpeclipse.internal.compiler.ast;
12
13 public abstract class OperatorExpression extends Expression implements OperatorIds {
14
15         public static int[][] ResolveTypeTables = 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                 ResolveTypeTables[AND] = get_AND();
27                 ResolveTypeTables[AND_AND] = get_AND_AND();
28                 ResolveTypeTables[DIVIDE] = get_DIVIDE();
29                 ResolveTypeTables[EQUAL_EQUAL] = get_EQUAL_EQUAL();
30                 ResolveTypeTables[GREATER] = get_GREATER();
31                 ResolveTypeTables[GREATER_EQUAL] = get_GREATER_EQUAL();
32                 ResolveTypeTables[LEFT_SHIFT] = get_LEFT_SHIFT();
33                 ResolveTypeTables[LESS] = get_LESS();
34                 ResolveTypeTables[LESS_EQUAL] = get_LESS_EQUAL();
35                 ResolveTypeTables[MINUS] = get_MINUS();
36                 ResolveTypeTables[MULTIPLY] = get_MULTIPLY();
37                 ResolveTypeTables[OR] = get_OR();
38                 ResolveTypeTables[OR_OR] = get_OR_OR();
39                 ResolveTypeTables[PLUS] = get_PLUS();
40                 ResolveTypeTables[REMAINDER] = get_REMAINDER();
41                 ResolveTypeTables[RIGHT_SHIFT] = get_RIGHT_SHIFT();
42                 ResolveTypeTables[UNSIGNED_RIGHT_SHIFT] = get_UNSIGNED_RIGHT_SHIFT();
43                 ResolveTypeTables[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 = (ResolveTypeTables[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 String toStringExpression(){
1558
1559                 //subclass redefine toStringExpressionNoParenthesis()
1560                 return  "(" + toStringExpressionNoParenthesis() + ")";  //$NON-NLS-2$ //$NON-NLS-1$
1561         }
1562         
1563         public abstract String toStringExpressionNoParenthesis();
1564 }