Refactory: smarty.ui plugin.
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / impl / Constant.java
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.phpdt.internal.compiler.impl;
12
13 import net.sourceforge.phpdt.internal.compiler.ast.OperatorIds;
14 import net.sourceforge.phpdt.internal.compiler.lookup.TypeIds;
15 import net.sourceforge.phpdt.internal.compiler.problem.ShouldNotImplement;
16 import net.sourceforge.phpdt.internal.compiler.util.Util;
17
18 public abstract class Constant implements TypeIds, OperatorIds {
19
20         public static final Constant NotAConstant = new DoubleConstant(Double.NaN);
21
22         public static final IntConstant Zero = new IntConstant(0);
23
24         public static final IntConstant Two = new IntConstant(2);
25
26         public static final IntConstant One = new IntConstant(1);
27
28         public boolean booleanValue() {
29
30                 throw new ShouldNotImplement(Util.bind(
31                                 "constant.cannotCastedInto", typeName(), "boolean")); //$NON-NLS-1$ //$NON-NLS-2$
32         }
33
34         public byte byteValue() {
35
36                 throw new ShouldNotImplement(Util.bind(
37                                 "constant.cannotCastedInto", typeName(), "byte")); //$NON-NLS-1$ //$NON-NLS-2$
38         }
39
40         public final Constant castTo(int conversionToTargetType) {
41                 // the cast is an int of the form
42                 // (castId<<4)+typeId (in order to follow the
43                 // user written style (cast)expression ....
44
45                 if (this == NotAConstant)
46                         return NotAConstant;
47                 switch (conversionToTargetType) {
48                 case T_undefined:
49                         return this;
50                         // TARGET TYPE <- FROM TYPE
51                         // case (T_undefined<<4)+T_undefined : return NotAConstant;
52                         // case (T_undefined<<4)+T_byte : return NotAConstant;
53                         // case (T_undefined<<4)+T_long : return NotAConstant;
54                         // case (T_undefined<<4)+T_short : return NotAConstant;
55                         // case (T_undefined<<4)+T_void : return NotAConstant;
56                         // case (T_undefined<<4)+T_String : return NotAConstant;
57                         // case (T_undefined<<4)+T_Object : return NotAConstant;
58                         // case (T_undefined<<4)+T_double : return NotAConstant;
59                         // case (T_undefined<<4)+T_float : return NotAConstant;
60                         // case (T_undefined<<4)+T_boolean : return NotAConstant;
61                         // case (T_undefined<<4)+T_char : return NotAConstant;
62                         // case (T_undefined<<4)+T_int : return NotAConstant;
63
64                         // case (T_byte<<4)+T_undefined : return NotAConstant;
65                 case (T_byte << 4) + T_byte:
66                         return this;
67                 case (T_byte << 4) + T_long:
68                         return Constant.fromValue((byte) this.longValue());
69                 case (T_byte << 4) + T_short:
70                         return Constant.fromValue((byte) this.shortValue());
71                         // case (T_byte<<4)+T_void : return NotAConstant;
72                         // case (T_byte<<4)+T_String : return NotAConstant;
73                         // case (T_byte<<4)+T_Object : return NotAConstant;
74                 case (T_byte << 4) + T_double:
75                         return Constant.fromValue((byte) this.doubleValue());
76                 case (T_byte << 4) + T_float:
77                         return Constant.fromValue((byte) this.floatValue());
78                         // case (T_byte<<4)+T_boolean : return NotAConstant;
79                 case (T_byte << 4) + T_char:
80                         return Constant.fromValue((byte) this.charValue());
81                 case (T_byte << 4) + T_int:
82                         return Constant.fromValue((byte) this.intValue());
83
84                         // case (T_long<<4)+T_undefined : return NotAConstant;
85                 case (T_long << 4) + T_byte:
86                         return Constant.fromValue((long) this.byteValue());
87                 case (T_long << 4) + T_long:
88                         return this;
89                 case (T_long << 4) + T_short:
90                         return Constant.fromValue((long) this.shortValue());
91                         // case (T_long<<4)+T_void : return NotAConstant;
92                         // case (T_long<<4)+T_String : return NotAConstant;
93                         // case (T_long<<4)+T_Object : return NotAConstant;
94                 case (T_long << 4) + T_double:
95                         return Constant.fromValue((long) this.doubleValue());
96                 case (T_long << 4) + T_float:
97                         return Constant.fromValue((long) this.floatValue());
98                         // case (T_long<<4)+T_boolean : return NotAConstant;
99                 case (T_long << 4) + T_char:
100                         return Constant.fromValue((long) this.charValue());
101                 case (T_long << 4) + T_int:
102                         return Constant.fromValue((long) this.intValue());
103
104                         // case (T_short<<4)+T_undefined : return NotAConstant;
105                 case (T_short << 4) + T_byte:
106                         return Constant.fromValue((short) this.byteValue());
107                 case (T_short << 4) + T_long:
108                         return Constant.fromValue((short) this.longValue());
109                 case (T_short << 4) + T_short:
110                         return this;
111                         // case (T_short<<4)+T_void : return NotAConstant;
112                         // case (T_short<<4)+T_String : return NotAConstant;
113                         // case (T_short<<4)+T_Object : return NotAConstant;
114                 case (T_short << 4) + T_double:
115                         return Constant.fromValue((short) this.doubleValue());
116                 case (T_short << 4) + T_float:
117                         return Constant.fromValue((short) this.floatValue());
118                         // case (T_short<<4)+T_boolean : return NotAConstant;
119                 case (T_short << 4) + T_char:
120                         return Constant.fromValue((short) this.charValue());
121                 case (T_short << 4) + T_int:
122                         return Constant.fromValue((short) this.intValue());
123
124                         // case (T_void<<4)+T_undefined : return NotAConstant;
125                         // case (T_void<<4)+T_byte : return NotAConstant;
126                         // case (T_void<<4)+T_long : return NotAConstant;
127                         // case (T_void<<4)+T_short : return NotAConstant;
128                         // case (T_void<<4)+T_void : return NotAConstant;
129                         // case (T_void<<4)+T_String : return NotAConstant;
130                         // case (T_void<<4)+T_Object : return NotAConstant;
131                         // case (T_void<<4)+T_double : return NotAConstant;
132                         // case (T_void<<4)+T_float : return NotAConstant;
133                         // case (T_void<<4)+T_boolean : return NotAConstant;
134                         // case (T_void<<4)+T_char : return NotAConstant;
135                         // case (T_void<<4)+T_int : return NotAConstant;
136
137                         // case (T_String<<4)+T_undefined : return NotAConstant;
138                         // case (T_String<<4)+T_byte : return NotAConstant;
139                         // case (T_String<<4)+T_long : return NotAConstant;
140                         // case (T_String<<4)+T_short : return NotAConstant;
141                         // case (T_String<<4)+T_void : return NotAConstant;
142                 case (T_String << 4) + T_String:
143                         return this;
144                         // case (T_String<<4)+T_Object : return NotAConstant;
145                         // case (T_String<<4)+T_double : return NotAConstant;
146                         // case (T_String<<4)+T_float : return NotAConstant;
147                         // case (T_String<<4)+T_boolean : return NotAConstant;
148                         // case (T_String<<4)+T_char : return NotAConstant;
149                         // case (T_String<<4)+T_int : return NotAConstant;
150
151                         // case (T_Object<<4)+T_undefined : return NotAConstant;
152                         // case (T_Object<<4)+T_byte : return NotAConstant;
153                         // case (T_Object<<4)+T_long : return NotAConstant;
154                         // case (T_Object<<4)+T_short : return NotAConstant;
155                         // case (T_Object<<4)+T_void : return NotAConstant;
156                         // case (T_Object<<4)+T_String : return NotAConstant;
157                         // case (T_Object<<4)+T_Object : return NotAConstant;
158                         // case (T_Object<<4)+T_double : return NotAConstant;
159                         // case (T_Object<<4)+T_float : return NotAConstant;
160                         // case (T_Object<<4)+T_boolean : return NotAConstant;
161                         // case (T_Object<<4)+T_char : return NotAConstant;
162                         // case (T_Object<<4)+T_int : return NotAConstant;
163
164                         // case (T_double<<4)+T_undefined : return NotAConstant;
165                 case (T_double << 4) + T_byte:
166                         return Constant.fromValue((double) this.byteValue());
167                 case (T_double << 4) + T_long:
168                         return Constant.fromValue((double) this.longValue());
169                 case (T_double << 4) + T_short:
170                         return Constant.fromValue((double) this.shortValue());
171                         // case (T_double<<4)+T_void : return NotAConstant;
172                         // case (T_double<<4)+T_String : return NotAConstant;
173                         // case (T_double<<4)+T_Object : return NotAConstant;
174                 case (T_double << 4) + T_double:
175                         return this;
176                 case (T_double << 4) + T_float:
177                         return Constant.fromValue((double) this.floatValue());
178                         // case (T_double<<4)+T_boolean : return NotAConstant;
179                 case (T_double << 4) + T_char:
180                         return Constant.fromValue((double) this.charValue());
181                 case (T_double << 4) + T_int:
182                         return Constant.fromValue((double) this.intValue());
183
184                         // case (T_float<<4)+T_undefined : return NotAConstant;
185                 case (T_float << 4) + T_byte:
186                         return Constant.fromValue((float) this.byteValue());
187                 case (T_float << 4) + T_long:
188                         return Constant.fromValue((float) this.longValue());
189                 case (T_float << 4) + T_short:
190                         return Constant.fromValue((float) this.shortValue());
191                         // case (T_float<<4)+T_void : return NotAConstant;
192                         // case (T_float<<4)+T_String : return NotAConstant;
193                         // case (T_float<<4)+T_Object : return NotAConstant;
194                 case (T_float << 4) + T_double:
195                         return Constant.fromValue((float) this.doubleValue());
196                 case (T_float << 4) + T_float:
197                         return this;
198                         // case (T_float<<4)+T_boolean : return NotAConstant;
199                 case (T_float << 4) + T_char:
200                         return Constant.fromValue((float) this.charValue());
201                 case (T_float << 4) + T_int:
202                         return Constant.fromValue((float) this.intValue());
203
204                         // case (T_boolean<<4)+T_undefined : return NotAConstant;
205                         // case (T_boolean<<4)+T_byte : return NotAConstant;
206                         // case (T_boolean<<4)+T_long : return NotAConstant;
207                         // case (T_boolean<<4)+T_short : return NotAConstant;
208                         // case (T_boolean<<4)+T_void : return NotAConstant;
209                         // case (T_boolean<<4)+T_String : return NotAConstant;
210                         // case (T_boolean<<4)+T_Object : return NotAConstant;
211                         // case (T_boolean<<4)+T_double : return NotAConstant;
212                         // case (T_boolean<<4)+T_float : return NotAConstant;
213                 case (T_boolean << 4) + T_boolean:
214                         return this;
215                         // case (T_boolean<<4)+T_char : return NotAConstant;
216                         // case (T_boolean<<4)+T_int : return NotAConstant;
217
218                         // case (T_char<<4)+T_undefined : return NotAConstant;
219                 case (T_char << 4) + T_byte:
220                         return Constant.fromValue((char) this.byteValue());
221                 case (T_char << 4) + T_long:
222                         return Constant.fromValue((char) this.longValue());
223                 case (T_char << 4) + T_short:
224                         return Constant.fromValue((char) this.shortValue());
225                         // case (T_char<<4)+T_void : return NotAConstant;
226                         // case (T_char<<4)+T_String : return NotAConstant;
227                         // case (T_char<<4)+T_Object : return NotAConstant;
228                 case (T_char << 4) + T_double:
229                         return Constant.fromValue((char) this.doubleValue());
230                 case (T_char << 4) + T_float:
231                         return Constant.fromValue((char) this.floatValue());
232                         // case (T_char<<4)+T_boolean : return NotAConstant;
233                 case (T_char << 4) + T_char:
234                         return this;
235                 case (T_char << 4) + T_int:
236                         return Constant.fromValue((char) this.intValue());
237
238                         // case (T_int<<4)+T_undefined : return NotAConstant;
239                 case (T_int << 4) + T_byte:
240                         return Constant.fromValue((int) this.byteValue());
241                 case (T_int << 4) + T_long:
242                         return Constant.fromValue((int) this.longValue());
243                 case (T_int << 4) + T_short:
244                         return Constant.fromValue((int) this.shortValue());
245                         // case (T_int<<4)+T_void : return NotAConstant;
246                         // case (T_int<<4)+T_String : return NotAConstant;
247                         // case (T_int<<4)+T_Object : return NotAConstant;
248                 case (T_int << 4) + T_double:
249                         return Constant.fromValue((int) this.doubleValue());
250                 case (T_int << 4) + T_float:
251                         return Constant.fromValue((int) this.floatValue());
252                         // case (T_int<<4)+T_boolean : return NotAConstant;
253                 case (T_int << 4) + T_char:
254                         return Constant.fromValue((int) this.charValue());
255                 case (T_int << 4) + T_int:
256                         return this;
257
258                 }
259
260                 return NotAConstant;
261         }
262
263         public char charValue() {
264
265                 throw new ShouldNotImplement(Util.bind(
266                                 "constant.cannotCastedInto", typeName(), "char")); //$NON-NLS-1$ //$NON-NLS-2$
267         }
268
269         public static final Constant computeConstantOperation(Constant cst, int id,
270                         int operator) {
271
272                 switch (operator) {
273                 case NOT:
274                         return Constant.fromValue(!cst.booleanValue());
275                 case PLUS:
276                         return cst;
277                 case MINUS: // the two special -9223372036854775808L and -2147483648 are
278                                         // inlined at parseTime
279                         switch (id) {
280                         case T_float:
281                                 float f;
282                                 if ((f = cst.floatValue()) == 0.0f) { // positive and negative
283                                                                                                                 // 0....
284                                         if (Float.floatToIntBits(f) == 0)
285                                                 return Constant.fromValue(-0.0f);
286                                         else
287                                                 return Constant.fromValue(0.0f);
288                                 }
289                                 break; // default case
290                         case T_double:
291                                 double d;
292                                 if ((d = cst.doubleValue()) == 0.0d) { // positive and negative
293                                                                                                                 // 0....
294                                         if (Double.doubleToLongBits(d) == 0)
295                                                 return Constant.fromValue(-0.0d);
296                                         else
297                                                 return Constant.fromValue(0.0d);
298                                 }
299                                 break; // default case
300                         }
301                         return computeConstantOperationMINUS(Zero, T_int, operator, cst, id);
302                 case TWIDDLE:
303                         switch (id) {
304                         case T_char:
305                                 return Constant.fromValue(~cst.charValue());
306                         case T_byte:
307                                 return Constant.fromValue(~cst.byteValue());
308                         case T_short:
309                                 return Constant.fromValue(~cst.shortValue());
310                         case T_int:
311                                 return Constant.fromValue(~cst.intValue());
312                         case T_long:
313                                 return Constant.fromValue(~cst.longValue());
314                         default:
315                                 return NotAConstant;
316                         }
317                 default:
318                         return NotAConstant;
319                 }
320         }
321
322         public static final Constant computeConstantOperation(Constant left,
323                         int leftId, int operator, Constant right, int rightId) {
324
325                 switch (operator) {
326                 case AND:
327                         return computeConstantOperationAND(left, leftId, operator, right,
328                                         rightId);
329                 case AND_AND:
330                         return computeConstantOperationAND_AND(left, leftId, operator,
331                                         right, rightId);
332                 case DIVIDE:
333                         return computeConstantOperationDIVIDE(left, leftId, operator,
334                                         right, rightId);
335                 case GREATER:
336                         return computeConstantOperationGREATER(left, leftId, operator,
337                                         right, rightId);
338                 case GREATER_EQUAL:
339                         return computeConstantOperationGREATER_EQUAL(left, leftId,
340                                         operator, right, rightId);
341                 case LEFT_SHIFT:
342                         return computeConstantOperationLEFT_SHIFT(left, leftId, operator,
343                                         right, rightId);
344                 case LESS:
345                         return computeConstantOperationLESS(left, leftId, operator, right,
346                                         rightId);
347                 case LESS_EQUAL:
348                         return computeConstantOperationLESS_EQUAL(left, leftId, operator,
349                                         right, rightId);
350                 case MINUS:
351                         return computeConstantOperationMINUS(left, leftId, operator, right,
352                                         rightId);
353                 case MULTIPLY:
354                         return computeConstantOperationMULTIPLY(left, leftId, operator,
355                                         right, rightId);
356                 case OR:
357                         return computeConstantOperationOR(left, leftId, operator, right,
358                                         rightId);
359                 case OR_OR:
360                         return computeConstantOperationOR_OR(left, leftId, operator, right,
361                                         rightId);
362                 case PLUS:
363                         return computeConstantOperationPLUS(left, leftId, operator, right,
364                                         rightId);
365                 case REMAINDER:
366                         return computeConstantOperationREMAINDER(left, leftId, operator,
367                                         right, rightId);
368                 case RIGHT_SHIFT:
369                         return computeConstantOperationRIGHT_SHIFT(left, leftId, operator,
370                                         right, rightId);
371                 case UNSIGNED_RIGHT_SHIFT:
372                         return computeConstantOperationUNSIGNED_RIGHT_SHIFT(left, leftId,
373                                         operator, right, rightId);
374                 case XOR:
375                         return computeConstantOperationXOR(left, leftId, operator, right,
376                                         rightId);
377
378                 default:
379                         return NotAConstant;
380                 }
381         }
382
383         public static final Constant computeConstantOperationAND(Constant left,
384                         int leftId, int operator, Constant right, int rightId) {
385
386                 switch (leftId) {
387                 case T_boolean:
388                         return Constant.fromValue(left.booleanValue()
389                                         & right.booleanValue());
390                 case T_char:
391                         switch (rightId) {
392                         case T_char:
393                                 return Constant.fromValue(left.charValue() & right.charValue());
394                         case T_byte:
395                                 return Constant.fromValue(left.charValue() & right.byteValue());
396                         case T_short:
397                                 return Constant
398                                                 .fromValue(left.charValue() & right.shortValue());
399                         case T_int:
400                                 return Constant.fromValue(left.charValue() & right.intValue());
401                         case T_long:
402                                 return Constant.fromValue(left.charValue() & right.longValue());
403                         }
404                         break;
405                 case T_byte:
406                         switch (rightId) {
407                         case T_char:
408                                 return Constant.fromValue(left.byteValue() & right.charValue());
409                         case T_byte:
410                                 return Constant.fromValue(left.byteValue() & right.byteValue());
411                         case T_short:
412                                 return Constant
413                                                 .fromValue(left.byteValue() & right.shortValue());
414                         case T_int:
415                                 return Constant.fromValue(left.byteValue() & right.intValue());
416                         case T_long:
417                                 return Constant.fromValue(left.byteValue() & right.longValue());
418                         }
419                         break;
420                 case T_short:
421                         switch (rightId) {
422                         case T_char:
423                                 return Constant
424                                                 .fromValue(left.shortValue() & right.charValue());
425                         case T_byte:
426                                 return Constant
427                                                 .fromValue(left.shortValue() & right.byteValue());
428                         case T_short:
429                                 return Constant.fromValue(left.shortValue()
430                                                 & right.shortValue());
431                         case T_int:
432                                 return Constant.fromValue(left.shortValue() & right.intValue());
433                         case T_long:
434                                 return Constant
435                                                 .fromValue(left.shortValue() & right.longValue());
436                         }
437                         break;
438                 case T_int:
439                         switch (rightId) {
440                         case T_char:
441                                 return Constant.fromValue(left.intValue() & right.charValue());
442                         case T_byte:
443                                 return Constant.fromValue(left.intValue() & right.byteValue());
444                         case T_short:
445                                 return Constant.fromValue(left.intValue() & right.shortValue());
446                         case T_int:
447                                 return Constant.fromValue(left.intValue() & right.intValue());
448                         case T_long:
449                                 return Constant.fromValue(left.intValue() & right.longValue());
450                         }
451                         break;
452                 case T_long:
453                         switch (rightId) {
454                         case T_char:
455                                 return Constant.fromValue(left.longValue() & right.charValue());
456                         case T_byte:
457                                 return Constant.fromValue(left.longValue() & right.byteValue());
458                         case T_short:
459                                 return Constant
460                                                 .fromValue(left.longValue() & right.shortValue());
461                         case T_int:
462                                 return Constant.fromValue(left.longValue() & right.intValue());
463                         case T_long:
464                                 return Constant.fromValue(left.longValue() & right.longValue());
465                         }
466                 }
467
468                 return NotAConstant;
469         }
470
471         public static final Constant computeConstantOperationAND_AND(Constant left,
472                         int leftId, int operator, Constant right, int rightId) {
473
474                 return Constant.fromValue(left.booleanValue() && right.booleanValue());
475         }
476
477         public static final Constant computeConstantOperationDIVIDE(Constant left,
478                         int leftId, int operator, Constant right, int rightId) {
479                 // division by zero must be handled outside this method (error
480                 // reporting)
481
482                 switch (leftId) {
483                 case T_char:
484                         switch (rightId) {
485                         case T_char:
486                                 return Constant.fromValue(left.charValue() / right.charValue());
487                         case T_float:
488                                 return Constant
489                                                 .fromValue(left.charValue() / right.floatValue());
490                         case T_double:
491                                 return Constant.fromValue(left.charValue()
492                                                 / right.doubleValue());
493                         case T_byte:
494                                 return Constant.fromValue(left.charValue() / right.byteValue());
495                         case T_short:
496                                 return Constant
497                                                 .fromValue(left.charValue() / right.shortValue());
498                         case T_int:
499                                 return Constant.fromValue(left.charValue() / right.intValue());
500                         case T_long:
501                                 return Constant.fromValue(left.charValue() / right.longValue());
502                         }
503                         break;
504                 case T_float:
505                         switch (rightId) {
506                         case T_char:
507                                 return Constant
508                                                 .fromValue(left.floatValue() / right.charValue());
509                         case T_float:
510                                 return Constant.fromValue(left.floatValue()
511                                                 / right.floatValue());
512                         case T_double:
513                                 return Constant.fromValue(left.floatValue()
514                                                 / right.doubleValue());
515                         case T_byte:
516                                 return Constant
517                                                 .fromValue(left.floatValue() / right.byteValue());
518                         case T_short:
519                                 return Constant.fromValue(left.floatValue()
520                                                 / right.shortValue());
521                         case T_int:
522                                 return Constant.fromValue(left.floatValue() / right.intValue());
523                         case T_long:
524                                 return Constant
525                                                 .fromValue(left.floatValue() / right.longValue());
526                         }
527                         break;
528                 case T_double:
529                         switch (rightId) {
530                         case T_char:
531                                 return Constant.fromValue(left.doubleValue()
532                                                 / right.charValue());
533                         case T_float:
534                                 return Constant.fromValue(left.doubleValue()
535                                                 / right.floatValue());
536                         case T_double:
537                                 return Constant.fromValue(left.doubleValue()
538                                                 / right.doubleValue());
539                         case T_byte:
540                                 return Constant.fromValue(left.doubleValue()
541                                                 / right.byteValue());
542                         case T_short:
543                                 return Constant.fromValue(left.doubleValue()
544                                                 / right.shortValue());
545                         case T_int:
546                                 return Constant
547                                                 .fromValue(left.doubleValue() / right.intValue());
548                         case T_long:
549                                 return Constant.fromValue(left.doubleValue()
550                                                 / right.longValue());
551                         }
552                         break;
553                 case T_byte:
554                         switch (rightId) {
555                         case T_char:
556                                 return Constant.fromValue(left.byteValue() / right.charValue());
557                         case T_float:
558                                 return Constant
559                                                 .fromValue(left.byteValue() / right.floatValue());
560                         case T_double:
561                                 return Constant.fromValue(left.byteValue()
562                                                 / right.doubleValue());
563                         case T_byte:
564                                 return Constant.fromValue(left.byteValue() / right.byteValue());
565                         case T_short:
566                                 return Constant
567                                                 .fromValue(left.byteValue() / right.shortValue());
568                         case T_int:
569                                 return Constant.fromValue(left.byteValue() / right.intValue());
570                         case T_long:
571                                 return Constant.fromValue(left.byteValue() / right.longValue());
572                         }
573                         break;
574                 case T_short:
575                         switch (rightId) {
576                         case T_char:
577                                 return Constant
578                                                 .fromValue(left.shortValue() / right.charValue());
579                         case T_float:
580                                 return Constant.fromValue(left.shortValue()
581                                                 / right.floatValue());
582                         case T_double:
583                                 return Constant.fromValue(left.shortValue()
584                                                 / right.doubleValue());
585                         case T_byte:
586                                 return Constant
587                                                 .fromValue(left.shortValue() / right.byteValue());
588                         case T_short:
589                                 return Constant.fromValue(left.shortValue()
590                                                 / right.shortValue());
591                         case T_int:
592                                 return Constant.fromValue(left.shortValue() / right.intValue());
593                         case T_long:
594                                 return Constant
595                                                 .fromValue(left.shortValue() / right.longValue());
596                         }
597                         break;
598                 case T_int:
599                         switch (rightId) {
600                         case T_char:
601                                 return Constant.fromValue(left.intValue() / right.charValue());
602                         case T_float:
603                                 return Constant.fromValue(left.intValue() / right.floatValue());
604                         case T_double:
605                                 return Constant
606                                                 .fromValue(left.intValue() / right.doubleValue());
607                         case T_byte:
608                                 return Constant.fromValue(left.intValue() / right.byteValue());
609                         case T_short:
610                                 return Constant.fromValue(left.intValue() / right.shortValue());
611                         case T_int:
612                                 return Constant.fromValue(left.intValue() / right.intValue());
613                         case T_long:
614                                 return Constant.fromValue(left.intValue() / right.longValue());
615                         }
616                         break;
617                 case T_long:
618                         switch (rightId) {
619                         case T_char:
620                                 return Constant.fromValue(left.longValue() / right.charValue());
621                         case T_float:
622                                 return Constant
623                                                 .fromValue(left.longValue() / right.floatValue());
624                         case T_double:
625                                 return Constant.fromValue(left.longValue()
626                                                 / right.doubleValue());
627                         case T_byte:
628                                 return Constant.fromValue(left.longValue() / right.byteValue());
629                         case T_short:
630                                 return Constant
631                                                 .fromValue(left.longValue() / right.shortValue());
632                         case T_int:
633                                 return Constant.fromValue(left.longValue() / right.intValue());
634                         case T_long:
635                                 return Constant.fromValue(left.longValue() / right.longValue());
636                         }
637
638                 }
639
640                 return NotAConstant;
641         }
642
643         public static final Constant computeConstantOperationEQUAL_EQUAL(
644                         Constant left, int leftId, int operator, Constant right, int rightId) {
645
646                 switch (leftId) {
647                 case T_boolean:
648                         if (rightId == T_boolean) {
649                                 return Constant.fromValue(left.booleanValue() == right
650                                                 .booleanValue());
651                         }
652                         break;
653                 case T_char:
654                         switch (rightId) {
655                         case T_char:
656                                 return Constant
657                                                 .fromValue(left.charValue() == right.charValue());
658                         case T_float:
659                                 return Constant.fromValue(left.charValue() == right
660                                                 .floatValue());
661                         case T_double:
662                                 return Constant.fromValue(left.charValue() == right
663                                                 .doubleValue());
664                         case T_byte:
665                                 return Constant
666                                                 .fromValue(left.charValue() == right.byteValue());
667                         case T_short:
668                                 return Constant.fromValue(left.charValue() == right
669                                                 .shortValue());
670                         case T_int:
671                                 return Constant.fromValue(left.charValue() == right.intValue());
672                         case T_long:
673                                 return Constant
674                                                 .fromValue(left.charValue() == right.longValue());
675                         }
676                         break;
677                 case T_float:
678                         switch (rightId) {
679                         case T_char:
680                                 return Constant.fromValue(left.floatValue() == right
681                                                 .charValue());
682                         case T_float:
683                                 return Constant.fromValue(left.floatValue() == right
684                                                 .floatValue());
685                         case T_double:
686                                 return Constant.fromValue(left.floatValue() == right
687                                                 .doubleValue());
688                         case T_byte:
689                                 return Constant.fromValue(left.floatValue() == right
690                                                 .byteValue());
691                         case T_short:
692                                 return Constant.fromValue(left.floatValue() == right
693                                                 .shortValue());
694                         case T_int:
695                                 return Constant
696                                                 .fromValue(left.floatValue() == right.intValue());
697                         case T_long:
698                                 return Constant.fromValue(left.floatValue() == right
699                                                 .longValue());
700                         }
701                         break;
702                 case T_double:
703                         switch (rightId) {
704                         case T_char:
705                                 return Constant.fromValue(left.doubleValue() == right
706                                                 .charValue());
707                         case T_float:
708                                 return Constant.fromValue(left.doubleValue() == right
709                                                 .floatValue());
710                         case T_double:
711                                 return Constant.fromValue(left.doubleValue() == right
712                                                 .doubleValue());
713                         case T_byte:
714                                 return Constant.fromValue(left.doubleValue() == right
715                                                 .byteValue());
716                         case T_short:
717                                 return Constant.fromValue(left.doubleValue() == right
718                                                 .shortValue());
719                         case T_int:
720                                 return Constant.fromValue(left.doubleValue() == right
721                                                 .intValue());
722                         case T_long:
723                                 return Constant.fromValue(left.doubleValue() == right
724                                                 .longValue());
725                         }
726                         break;
727                 case T_byte:
728                         switch (rightId) {
729                         case T_char:
730                                 return Constant
731                                                 .fromValue(left.byteValue() == right.charValue());
732                         case T_float:
733                                 return Constant.fromValue(left.byteValue() == right
734                                                 .floatValue());
735                         case T_double:
736                                 return Constant.fromValue(left.byteValue() == right
737                                                 .doubleValue());
738                         case T_byte:
739                                 return Constant
740                                                 .fromValue(left.byteValue() == right.byteValue());
741                         case T_short:
742                                 return Constant.fromValue(left.byteValue() == right
743                                                 .shortValue());
744                         case T_int:
745                                 return Constant.fromValue(left.byteValue() == right.intValue());
746                         case T_long:
747                                 return Constant
748                                                 .fromValue(left.byteValue() == right.longValue());
749                         }
750                         break;
751                 case T_short:
752                         switch (rightId) {
753                         case T_char:
754                                 return Constant.fromValue(left.shortValue() == right
755                                                 .charValue());
756                         case T_float:
757                                 return Constant.fromValue(left.shortValue() == right
758                                                 .floatValue());
759                         case T_double:
760                                 return Constant.fromValue(left.shortValue() == right
761                                                 .doubleValue());
762                         case T_byte:
763                                 return Constant.fromValue(left.shortValue() == right
764                                                 .byteValue());
765                         case T_short:
766                                 return Constant.fromValue(left.shortValue() == right
767                                                 .shortValue());
768                         case T_int:
769                                 return Constant
770                                                 .fromValue(left.shortValue() == right.intValue());
771                         case T_long:
772                                 return Constant.fromValue(left.shortValue() == right
773                                                 .longValue());
774                         }
775                         break;
776                 case T_int:
777                         switch (rightId) {
778                         case T_char:
779                                 return Constant.fromValue(left.intValue() == right.charValue());
780                         case T_float:
781                                 return Constant
782                                                 .fromValue(left.intValue() == right.floatValue());
783                         case T_double:
784                                 return Constant.fromValue(left.intValue() == right
785                                                 .doubleValue());
786                         case T_byte:
787                                 return Constant.fromValue(left.intValue() == right.byteValue());
788                         case T_short:
789                                 return Constant
790                                                 .fromValue(left.intValue() == right.shortValue());
791                         case T_int:
792                                 return Constant.fromValue(left.intValue() == right.intValue());
793                         case T_long:
794                                 return Constant.fromValue(left.intValue() == right.longValue());
795                         }
796                         break;
797                 case T_long:
798                         switch (rightId) {
799                         case T_char:
800                                 return Constant
801                                                 .fromValue(left.longValue() == right.charValue());
802                         case T_float:
803                                 return Constant.fromValue(left.longValue() == right
804                                                 .floatValue());
805                         case T_double:
806                                 return Constant.fromValue(left.longValue() == right
807                                                 .doubleValue());
808                         case T_byte:
809                                 return Constant
810                                                 .fromValue(left.longValue() == right.byteValue());
811                         case T_short:
812                                 return Constant.fromValue(left.longValue() == right
813                                                 .shortValue());
814                         case T_int:
815                                 return Constant.fromValue(left.longValue() == right.intValue());
816                         case T_long:
817                                 return Constant
818                                                 .fromValue(left.longValue() == right.longValue());
819                         }
820                         break;
821                 case T_String:
822                         if (rightId == T_String) {
823                                 // String are interned in th compiler==>thus if two string
824                                 // constant
825                                 // get to be compared, it is an equal on the vale which is done
826                                 return Constant.fromValue(((StringConstant) left)
827                                                 .compileTimeEqual((StringConstant) right));
828                         }
829                         break;
830                 case T_null:
831                         if (rightId == T_String) {
832                                 return Constant.fromValue(false);
833                         } else {
834                                 if (rightId == T_null) {
835                                         return Constant.fromValue(true);
836                                 }
837                         }
838                 }
839
840                 return Constant.fromValue(false);
841         }
842
843         public static final Constant computeConstantOperationGREATER(Constant left,
844                         int leftId, int operator, Constant right, int rightId) {
845
846                 switch (leftId) {
847                 case T_char:
848                         switch (rightId) {
849                         case T_char:
850                                 return Constant.fromValue(left.charValue() > right.charValue());
851                         case T_float:
852                                 return Constant
853                                                 .fromValue(left.charValue() > right.floatValue());
854                         case T_double:
855                                 return Constant.fromValue(left.charValue() > right
856                                                 .doubleValue());
857                         case T_byte:
858                                 return Constant.fromValue(left.charValue() > right.byteValue());
859                         case T_short:
860                                 return Constant
861                                                 .fromValue(left.charValue() > right.shortValue());
862                         case T_int:
863                                 return Constant.fromValue(left.charValue() > right.intValue());
864                         case T_long:
865                                 return Constant.fromValue(left.charValue() > right.longValue());
866                         }
867                         break;
868                 case T_float:
869                         switch (rightId) {
870                         case T_char:
871                                 return Constant
872                                                 .fromValue(left.floatValue() > right.charValue());
873                         case T_float:
874                                 return Constant.fromValue(left.floatValue() > right
875                                                 .floatValue());
876                         case T_double:
877                                 return Constant.fromValue(left.floatValue() > right
878                                                 .doubleValue());
879                         case T_byte:
880                                 return Constant
881                                                 .fromValue(left.floatValue() > right.byteValue());
882                         case T_short:
883                                 return Constant.fromValue(left.floatValue() > right
884                                                 .shortValue());
885                         case T_int:
886                                 return Constant.fromValue(left.floatValue() > right.intValue());
887                         case T_long:
888                                 return Constant
889                                                 .fromValue(left.floatValue() > right.longValue());
890                         }
891                         break;
892                 case T_double:
893                         switch (rightId) {
894                         case T_char:
895                                 return Constant.fromValue(left.doubleValue() > right
896                                                 .charValue());
897                         case T_float:
898                                 return Constant.fromValue(left.doubleValue() > right
899                                                 .floatValue());
900                         case T_double:
901                                 return Constant.fromValue(left.doubleValue() > right
902                                                 .doubleValue());
903                         case T_byte:
904                                 return Constant.fromValue(left.doubleValue() > right
905                                                 .byteValue());
906                         case T_short:
907                                 return Constant.fromValue(left.doubleValue() > right
908                                                 .shortValue());
909                         case T_int:
910                                 return Constant
911                                                 .fromValue(left.doubleValue() > right.intValue());
912                         case T_long:
913                                 return Constant.fromValue(left.doubleValue() > right
914                                                 .longValue());
915                         }
916                         break;
917                 case T_byte:
918                         switch (rightId) {
919                         case T_char:
920                                 return Constant.fromValue(left.byteValue() > right.charValue());
921                         case T_float:
922                                 return Constant
923                                                 .fromValue(left.byteValue() > right.floatValue());
924                         case T_double:
925                                 return Constant.fromValue(left.byteValue() > right
926                                                 .doubleValue());
927                         case T_byte:
928                                 return Constant.fromValue(left.byteValue() > right.byteValue());
929                         case T_short:
930                                 return Constant
931                                                 .fromValue(left.byteValue() > right.shortValue());
932                         case T_int:
933                                 return Constant.fromValue(left.byteValue() > right.intValue());
934                         case T_long:
935                                 return Constant.fromValue(left.byteValue() > right.longValue());
936                         }
937                         break;
938                 case T_short:
939                         switch (rightId) {
940                         case T_char:
941                                 return Constant
942                                                 .fromValue(left.shortValue() > right.charValue());
943                         case T_float:
944                                 return Constant.fromValue(left.shortValue() > right
945                                                 .floatValue());
946                         case T_double:
947                                 return Constant.fromValue(left.shortValue() > right
948                                                 .doubleValue());
949                         case T_byte:
950                                 return Constant
951                                                 .fromValue(left.shortValue() > right.byteValue());
952                         case T_short:
953                                 return Constant.fromValue(left.shortValue() > right
954                                                 .shortValue());
955                         case T_int:
956                                 return Constant.fromValue(left.shortValue() > right.intValue());
957                         case T_long:
958                                 return Constant
959                                                 .fromValue(left.shortValue() > right.longValue());
960                         }
961                         break;
962                 case T_int:
963                         switch (rightId) {
964                         case T_char:
965                                 return Constant.fromValue(left.intValue() > right.charValue());
966                         case T_float:
967                                 return Constant.fromValue(left.intValue() > right.floatValue());
968                         case T_double:
969                                 return Constant
970                                                 .fromValue(left.intValue() > right.doubleValue());
971                         case T_byte:
972                                 return Constant.fromValue(left.intValue() > right.byteValue());
973                         case T_short:
974                                 return Constant.fromValue(left.intValue() > right.shortValue());
975                         case T_int:
976                                 return Constant.fromValue(left.intValue() > right.intValue());
977                         case T_long:
978                                 return Constant.fromValue(left.intValue() > right.longValue());
979                         }
980                         break;
981                 case T_long:
982                         switch (rightId) {
983                         case T_char:
984                                 return Constant.fromValue(left.longValue() > right.charValue());
985                         case T_float:
986                                 return Constant
987                                                 .fromValue(left.longValue() > right.floatValue());
988                         case T_double:
989                                 return Constant.fromValue(left.longValue() > right
990                                                 .doubleValue());
991                         case T_byte:
992                                 return Constant.fromValue(left.longValue() > right.byteValue());
993                         case T_short:
994                                 return Constant
995                                                 .fromValue(left.longValue() > right.shortValue());
996                         case T_int:
997                                 return Constant.fromValue(left.longValue() > right.intValue());
998                         case T_long:
999                                 return Constant.fromValue(left.longValue() > right.longValue());
1000                         }
1001
1002                 }
1003
1004                 return NotAConstant;
1005         }
1006
1007         public static final Constant computeConstantOperationGREATER_EQUAL(
1008                         Constant left, int leftId, int operator, Constant right, int rightId) {
1009
1010                 switch (leftId) {
1011                 case T_char:
1012                         switch (rightId) {
1013                         case T_char:
1014                                 return Constant
1015                                                 .fromValue(left.charValue() >= right.charValue());
1016                         case T_float:
1017                                 return Constant.fromValue(left.charValue() >= right
1018                                                 .floatValue());
1019                         case T_double:
1020                                 return Constant.fromValue(left.charValue() >= right
1021                                                 .doubleValue());
1022                         case T_byte:
1023                                 return Constant
1024                                                 .fromValue(left.charValue() >= right.byteValue());
1025                         case T_short:
1026                                 return Constant.fromValue(left.charValue() >= right
1027                                                 .shortValue());
1028                         case T_int:
1029                                 return Constant.fromValue(left.charValue() >= right.intValue());
1030                         case T_long:
1031                                 return Constant
1032                                                 .fromValue(left.charValue() >= right.longValue());
1033                         }
1034                         break;
1035                 case T_float:
1036                         switch (rightId) {
1037                         case T_char:
1038                                 return Constant.fromValue(left.floatValue() >= right
1039                                                 .charValue());
1040                         case T_float:
1041                                 return Constant.fromValue(left.floatValue() >= right
1042                                                 .floatValue());
1043                         case T_double:
1044                                 return Constant.fromValue(left.floatValue() >= right
1045                                                 .doubleValue());
1046                         case T_byte:
1047                                 return Constant.fromValue(left.floatValue() >= right
1048                                                 .byteValue());
1049                         case T_short:
1050                                 return Constant.fromValue(left.floatValue() >= right
1051                                                 .shortValue());
1052                         case T_int:
1053                                 return Constant
1054                                                 .fromValue(left.floatValue() >= right.intValue());
1055                         case T_long:
1056                                 return Constant.fromValue(left.floatValue() >= right
1057                                                 .longValue());
1058                         }
1059                         break;
1060                 case T_double:
1061                         switch (rightId) {
1062                         case T_char:
1063                                 return Constant.fromValue(left.doubleValue() >= right
1064                                                 .charValue());
1065                         case T_float:
1066                                 return Constant.fromValue(left.doubleValue() >= right
1067                                                 .floatValue());
1068                         case T_double:
1069                                 return Constant.fromValue(left.doubleValue() >= right
1070                                                 .doubleValue());
1071                         case T_byte:
1072                                 return Constant.fromValue(left.doubleValue() >= right
1073                                                 .byteValue());
1074                         case T_short:
1075                                 return Constant.fromValue(left.doubleValue() >= right
1076                                                 .shortValue());
1077                         case T_int:
1078                                 return Constant.fromValue(left.doubleValue() >= right
1079                                                 .intValue());
1080                         case T_long:
1081                                 return Constant.fromValue(left.doubleValue() >= right
1082                                                 .longValue());
1083                         }
1084                         break;
1085                 case T_byte:
1086                         switch (rightId) {
1087                         case T_char:
1088                                 return Constant
1089                                                 .fromValue(left.byteValue() >= right.charValue());
1090                         case T_float:
1091                                 return Constant.fromValue(left.byteValue() >= right
1092                                                 .floatValue());
1093                         case T_double:
1094                                 return Constant.fromValue(left.byteValue() >= right
1095                                                 .doubleValue());
1096                         case T_byte:
1097                                 return Constant
1098                                                 .fromValue(left.byteValue() >= right.byteValue());
1099                         case T_short:
1100                                 return Constant.fromValue(left.byteValue() >= right
1101                                                 .shortValue());
1102                         case T_int:
1103                                 return Constant.fromValue(left.byteValue() >= right.intValue());
1104                         case T_long:
1105                                 return Constant
1106                                                 .fromValue(left.byteValue() >= right.longValue());
1107                         }
1108                         break;
1109                 case T_short:
1110                         switch (rightId) {
1111                         case T_char:
1112                                 return Constant.fromValue(left.shortValue() >= right
1113                                                 .charValue());
1114                         case T_float:
1115                                 return Constant.fromValue(left.shortValue() >= right
1116                                                 .floatValue());
1117                         case T_double:
1118                                 return Constant.fromValue(left.shortValue() >= right
1119                                                 .doubleValue());
1120                         case T_byte:
1121                                 return Constant.fromValue(left.shortValue() >= right
1122                                                 .byteValue());
1123                         case T_short:
1124                                 return Constant.fromValue(left.shortValue() >= right
1125                                                 .shortValue());
1126                         case T_int:
1127                                 return Constant
1128                                                 .fromValue(left.shortValue() >= right.intValue());
1129                         case T_long:
1130                                 return Constant.fromValue(left.shortValue() >= right
1131                                                 .longValue());
1132                         }
1133                         break;
1134                 case T_int:
1135                         switch (rightId) {
1136                         case T_char:
1137                                 return Constant.fromValue(left.intValue() >= right.charValue());
1138                         case T_float:
1139                                 return Constant
1140                                                 .fromValue(left.intValue() >= right.floatValue());
1141                         case T_double:
1142                                 return Constant.fromValue(left.intValue() >= right
1143                                                 .doubleValue());
1144                         case T_byte:
1145                                 return Constant.fromValue(left.intValue() >= right.byteValue());
1146                         case T_short:
1147                                 return Constant
1148                                                 .fromValue(left.intValue() >= right.shortValue());
1149                         case T_int:
1150                                 return Constant.fromValue(left.intValue() >= right.intValue());
1151                         case T_long:
1152                                 return Constant.fromValue(left.intValue() >= right.longValue());
1153                         }
1154                         break;
1155                 case T_long:
1156                         switch (rightId) {
1157                         case T_char:
1158                                 return Constant
1159                                                 .fromValue(left.longValue() >= right.charValue());
1160                         case T_float:
1161                                 return Constant.fromValue(left.longValue() >= right
1162                                                 .floatValue());
1163                         case T_double:
1164                                 return Constant.fromValue(left.longValue() >= right
1165                                                 .doubleValue());
1166                         case T_byte:
1167                                 return Constant
1168                                                 .fromValue(left.longValue() >= right.byteValue());
1169                         case T_short:
1170                                 return Constant.fromValue(left.longValue() >= right
1171                                                 .shortValue());
1172                         case T_int:
1173                                 return Constant.fromValue(left.longValue() >= right.intValue());
1174                         case T_long:
1175                                 return Constant
1176                                                 .fromValue(left.longValue() >= right.longValue());
1177                         }
1178
1179                 }
1180
1181                 return NotAConstant;
1182         }
1183
1184         public static final Constant computeConstantOperationLEFT_SHIFT(
1185                         Constant left, int leftId, int operator, Constant right, int rightId) {
1186
1187                 switch (leftId) {
1188                 case T_char:
1189                         switch (rightId) {
1190                         case T_char:
1191                                 return Constant
1192                                                 .fromValue(left.charValue() << right.charValue());
1193                         case T_byte:
1194                                 return Constant
1195                                                 .fromValue(left.charValue() << right.byteValue());
1196                         case T_short:
1197                                 return Constant.fromValue(left.charValue() << right
1198                                                 .shortValue());
1199                         case T_int:
1200                                 return Constant.fromValue(left.charValue() << right.intValue());
1201                         case T_long:
1202                                 return Constant
1203                                                 .fromValue(left.charValue() << right.longValue());
1204                         }
1205                         break;
1206                 case T_byte:
1207                         switch (rightId) {
1208                         case T_char:
1209                                 return Constant
1210                                                 .fromValue(left.byteValue() << right.charValue());
1211                         case T_byte:
1212                                 return Constant
1213                                                 .fromValue(left.byteValue() << right.byteValue());
1214                         case T_short:
1215                                 return Constant.fromValue(left.byteValue() << right
1216                                                 .shortValue());
1217                         case T_int:
1218                                 return Constant.fromValue(left.byteValue() << right.intValue());
1219                         case T_long:
1220                                 return Constant
1221                                                 .fromValue(left.byteValue() << right.longValue());
1222                         }
1223                         break;
1224                 case T_short:
1225                         switch (rightId) {
1226                         case T_char:
1227                                 return Constant.fromValue(left.shortValue() << right
1228                                                 .charValue());
1229                         case T_byte:
1230                                 return Constant.fromValue(left.shortValue() << right
1231                                                 .byteValue());
1232                         case T_short:
1233                                 return Constant.fromValue(left.shortValue() << right
1234                                                 .shortValue());
1235                         case T_int:
1236                                 return Constant
1237                                                 .fromValue(left.shortValue() << right.intValue());
1238                         case T_long:
1239                                 return Constant.fromValue(left.shortValue() << right
1240                                                 .longValue());
1241                         }
1242                         break;
1243                 case T_int:
1244                         switch (rightId) {
1245                         case T_char:
1246                                 return Constant.fromValue(left.intValue() << right.charValue());
1247                         case T_byte:
1248                                 return Constant.fromValue(left.intValue() << right.byteValue());
1249                         case T_short:
1250                                 return Constant
1251                                                 .fromValue(left.intValue() << right.shortValue());
1252                         case T_int:
1253                                 return Constant.fromValue(left.intValue() << right.intValue());
1254                         case T_long:
1255                                 return Constant.fromValue(left.intValue() << right.longValue());
1256                         }
1257                         break;
1258                 case T_long:
1259                         switch (rightId) {
1260                         case T_char:
1261                                 return Constant
1262                                                 .fromValue(left.longValue() << right.charValue());
1263                         case T_byte:
1264                                 return Constant
1265                                                 .fromValue(left.longValue() << right.byteValue());
1266                         case T_short:
1267                                 return Constant.fromValue(left.longValue() << right
1268                                                 .shortValue());
1269                         case T_int:
1270                                 return Constant.fromValue(left.longValue() << right.intValue());
1271                         case T_long:
1272                                 return Constant
1273                                                 .fromValue(left.longValue() << right.longValue());
1274                         }
1275
1276                 }
1277
1278                 return NotAConstant;
1279         }
1280
1281         public static final Constant computeConstantOperationLESS(Constant left,
1282                         int leftId, int operator, Constant right, int rightId) {
1283
1284                 switch (leftId) {
1285                 case T_char:
1286                         switch (rightId) {
1287                         case T_char:
1288                                 return Constant.fromValue(left.charValue() < right.charValue());
1289                         case T_float:
1290                                 return Constant
1291                                                 .fromValue(left.charValue() < right.floatValue());
1292                         case T_double:
1293                                 return Constant.fromValue(left.charValue() < right
1294                                                 .doubleValue());
1295                         case T_byte:
1296                                 return Constant.fromValue(left.charValue() < right.byteValue());
1297                         case T_short:
1298                                 return Constant
1299                                                 .fromValue(left.charValue() < right.shortValue());
1300                         case T_int:
1301                                 return Constant.fromValue(left.charValue() < right.intValue());
1302                         case T_long:
1303                                 return Constant.fromValue(left.charValue() < right.longValue());
1304                         }
1305                         break;
1306                 case T_float:
1307                         switch (rightId) {
1308                         case T_char:
1309                                 return Constant
1310                                                 .fromValue(left.floatValue() < right.charValue());
1311                         case T_float:
1312                                 return Constant.fromValue(left.floatValue() < right
1313                                                 .floatValue());
1314                         case T_double:
1315                                 return Constant.fromValue(left.floatValue() < right
1316                                                 .doubleValue());
1317                         case T_byte:
1318                                 return Constant
1319                                                 .fromValue(left.floatValue() < right.byteValue());
1320                         case T_short:
1321                                 return Constant.fromValue(left.floatValue() < right
1322                                                 .shortValue());
1323                         case T_int:
1324                                 return Constant.fromValue(left.floatValue() < right.intValue());
1325                         case T_long:
1326                                 return Constant
1327                                                 .fromValue(left.floatValue() < right.longValue());
1328                         }
1329                         break;
1330                 case T_double:
1331                         switch (rightId) {
1332                         case T_char:
1333                                 return Constant.fromValue(left.doubleValue() < right
1334                                                 .charValue());
1335                         case T_float:
1336                                 return Constant.fromValue(left.doubleValue() < right
1337                                                 .floatValue());
1338                         case T_double:
1339                                 return Constant.fromValue(left.doubleValue() < right
1340                                                 .doubleValue());
1341                         case T_byte:
1342                                 return Constant.fromValue(left.doubleValue() < right
1343                                                 .byteValue());
1344                         case T_short:
1345                                 return Constant.fromValue(left.doubleValue() < right
1346                                                 .shortValue());
1347                         case T_int:
1348                                 return Constant
1349                                                 .fromValue(left.doubleValue() < right.intValue());
1350                         case T_long:
1351                                 return Constant.fromValue(left.doubleValue() < right
1352                                                 .longValue());
1353                         }
1354                         break;
1355                 case T_byte:
1356                         switch (rightId) {
1357                         case T_char:
1358                                 return Constant.fromValue(left.byteValue() < right.charValue());
1359                         case T_float:
1360                                 return Constant
1361                                                 .fromValue(left.byteValue() < right.floatValue());
1362                         case T_double:
1363                                 return Constant.fromValue(left.byteValue() < right
1364                                                 .doubleValue());
1365                         case T_byte:
1366                                 return Constant.fromValue(left.byteValue() < right.byteValue());
1367                         case T_short:
1368                                 return Constant
1369                                                 .fromValue(left.byteValue() < right.shortValue());
1370                         case T_int:
1371                                 return Constant.fromValue(left.byteValue() < right.intValue());
1372                         case T_long:
1373                                 return Constant.fromValue(left.byteValue() < right.longValue());
1374                         }
1375                         break;
1376                 case T_short:
1377                         switch (rightId) {
1378                         case T_char:
1379                                 return Constant
1380                                                 .fromValue(left.shortValue() < right.charValue());
1381                         case T_float:
1382                                 return Constant.fromValue(left.shortValue() < right
1383                                                 .floatValue());
1384                         case T_double:
1385                                 return Constant.fromValue(left.shortValue() < right
1386                                                 .doubleValue());
1387                         case T_byte:
1388                                 return Constant
1389                                                 .fromValue(left.shortValue() < right.byteValue());
1390                         case T_short:
1391                                 return Constant.fromValue(left.shortValue() < right
1392                                                 .shortValue());
1393                         case T_int:
1394                                 return Constant.fromValue(left.shortValue() < right.intValue());
1395                         case T_long:
1396                                 return Constant
1397                                                 .fromValue(left.shortValue() < right.longValue());
1398                         }
1399                         break;
1400                 case T_int:
1401                         switch (rightId) {
1402                         case T_char:
1403                                 return Constant.fromValue(left.intValue() < right.charValue());
1404                         case T_float:
1405                                 return Constant.fromValue(left.intValue() < right.floatValue());
1406                         case T_double:
1407                                 return Constant
1408                                                 .fromValue(left.intValue() < right.doubleValue());
1409                         case T_byte:
1410                                 return Constant.fromValue(left.intValue() < right.byteValue());
1411                         case T_short:
1412                                 return Constant.fromValue(left.intValue() < right.shortValue());
1413                         case T_int:
1414                                 return Constant.fromValue(left.intValue() < right.intValue());
1415                         case T_long:
1416                                 return Constant.fromValue(left.intValue() < right.longValue());
1417                         }
1418                         break;
1419                 case T_long:
1420                         switch (rightId) {
1421                         case T_char:
1422                                 return Constant.fromValue(left.longValue() < right.charValue());
1423                         case T_float:
1424                                 return Constant
1425                                                 .fromValue(left.longValue() < right.floatValue());
1426                         case T_double:
1427                                 return Constant.fromValue(left.longValue() < right
1428                                                 .doubleValue());
1429                         case T_byte:
1430                                 return Constant.fromValue(left.longValue() < right.byteValue());
1431                         case T_short:
1432                                 return Constant
1433                                                 .fromValue(left.longValue() < right.shortValue());
1434                         case T_int:
1435                                 return Constant.fromValue(left.longValue() < right.intValue());
1436                         case T_long:
1437                                 return Constant.fromValue(left.longValue() < right.longValue());
1438                         }
1439
1440                 }
1441
1442                 return NotAConstant;
1443         }
1444
1445         public static final Constant computeConstantOperationLESS_EQUAL(
1446                         Constant left, int leftId, int operator, Constant right, int rightId) {
1447
1448                 switch (leftId) {
1449                 case T_char:
1450                         switch (rightId) {
1451                         case T_char:
1452                                 return Constant
1453                                                 .fromValue(left.charValue() <= right.charValue());
1454                         case T_float:
1455                                 return Constant.fromValue(left.charValue() <= right
1456                                                 .floatValue());
1457                         case T_double:
1458                                 return Constant.fromValue(left.charValue() <= right
1459                                                 .doubleValue());
1460                         case T_byte:
1461                                 return Constant
1462                                                 .fromValue(left.charValue() <= right.byteValue());
1463                         case T_short:
1464                                 return Constant.fromValue(left.charValue() <= right
1465                                                 .shortValue());
1466                         case T_int:
1467                                 return Constant.fromValue(left.charValue() <= right.intValue());
1468                         case T_long:
1469                                 return Constant
1470                                                 .fromValue(left.charValue() <= right.longValue());
1471                         }
1472                         break;
1473                 case T_float:
1474                         switch (rightId) {
1475                         case T_char:
1476                                 return Constant.fromValue(left.floatValue() <= right
1477                                                 .charValue());
1478                         case T_float:
1479                                 return Constant.fromValue(left.floatValue() <= right
1480                                                 .floatValue());
1481                         case T_double:
1482                                 return Constant.fromValue(left.floatValue() <= right
1483                                                 .doubleValue());
1484                         case T_byte:
1485                                 return Constant.fromValue(left.floatValue() <= right
1486                                                 .byteValue());
1487                         case T_short:
1488                                 return Constant.fromValue(left.floatValue() <= right
1489                                                 .shortValue());
1490                         case T_int:
1491                                 return Constant
1492                                                 .fromValue(left.floatValue() <= right.intValue());
1493                         case T_long:
1494                                 return Constant.fromValue(left.floatValue() <= right
1495                                                 .longValue());
1496                         }
1497                         break;
1498                 case T_double:
1499                         switch (rightId) {
1500                         case T_char:
1501                                 return Constant.fromValue(left.doubleValue() <= right
1502                                                 .charValue());
1503                         case T_float:
1504                                 return Constant.fromValue(left.doubleValue() <= right
1505                                                 .floatValue());
1506                         case T_double:
1507                                 return Constant.fromValue(left.doubleValue() <= right
1508                                                 .doubleValue());
1509                         case T_byte:
1510                                 return Constant.fromValue(left.doubleValue() <= right
1511                                                 .byteValue());
1512                         case T_short:
1513                                 return Constant.fromValue(left.doubleValue() <= right
1514                                                 .shortValue());
1515                         case T_int:
1516                                 return Constant.fromValue(left.doubleValue() <= right
1517                                                 .intValue());
1518                         case T_long:
1519                                 return Constant.fromValue(left.doubleValue() <= right
1520                                                 .longValue());
1521                         }
1522                         break;
1523                 case T_byte:
1524                         switch (rightId) {
1525                         case T_char:
1526                                 return Constant
1527                                                 .fromValue(left.byteValue() <= right.charValue());
1528                         case T_float:
1529                                 return Constant.fromValue(left.byteValue() <= right
1530                                                 .floatValue());
1531                         case T_double:
1532                                 return Constant.fromValue(left.byteValue() <= right
1533                                                 .doubleValue());
1534                         case T_byte:
1535                                 return Constant
1536                                                 .fromValue(left.byteValue() <= right.byteValue());
1537                         case T_short:
1538                                 return Constant.fromValue(left.byteValue() <= right
1539                                                 .shortValue());
1540                         case T_int:
1541                                 return Constant.fromValue(left.byteValue() <= right.intValue());
1542                         case T_long:
1543                                 return Constant
1544                                                 .fromValue(left.byteValue() <= right.longValue());
1545                         }
1546                         break;
1547                 case T_short:
1548                         switch (rightId) {
1549                         case T_char:
1550                                 return Constant.fromValue(left.shortValue() <= right
1551                                                 .charValue());
1552                         case T_float:
1553                                 return Constant.fromValue(left.shortValue() <= right
1554                                                 .floatValue());
1555                         case T_double:
1556                                 return Constant.fromValue(left.shortValue() <= right
1557                                                 .doubleValue());
1558                         case T_byte:
1559                                 return Constant.fromValue(left.shortValue() <= right
1560                                                 .byteValue());
1561                         case T_short:
1562                                 return Constant.fromValue(left.shortValue() <= right
1563                                                 .shortValue());
1564                         case T_int:
1565                                 return Constant
1566                                                 .fromValue(left.shortValue() <= right.intValue());
1567                         case T_long:
1568                                 return Constant.fromValue(left.shortValue() <= right
1569                                                 .longValue());
1570                         }
1571                         break;
1572                 case T_int:
1573                         switch (rightId) {
1574                         case T_char:
1575                                 return Constant.fromValue(left.intValue() <= right.charValue());
1576                         case T_float:
1577                                 return Constant
1578                                                 .fromValue(left.intValue() <= right.floatValue());
1579                         case T_double:
1580                                 return Constant.fromValue(left.intValue() <= right
1581                                                 .doubleValue());
1582                         case T_byte:
1583                                 return Constant.fromValue(left.intValue() <= right.byteValue());
1584                         case T_short:
1585                                 return Constant
1586                                                 .fromValue(left.intValue() <= right.shortValue());
1587                         case T_int:
1588                                 return Constant.fromValue(left.intValue() <= right.intValue());
1589                         case T_long:
1590                                 return Constant.fromValue(left.intValue() <= right.longValue());
1591                         }
1592                         break;
1593                 case T_long:
1594                         switch (rightId) {
1595                         case T_char:
1596                                 return Constant
1597                                                 .fromValue(left.longValue() <= right.charValue());
1598                         case T_float:
1599                                 return Constant.fromValue(left.longValue() <= right
1600                                                 .floatValue());
1601                         case T_double:
1602                                 return Constant.fromValue(left.longValue() <= right
1603                                                 .doubleValue());
1604                         case T_byte:
1605                                 return Constant
1606                                                 .fromValue(left.longValue() <= right.byteValue());
1607                         case T_short:
1608                                 return Constant.fromValue(left.longValue() <= right
1609                                                 .shortValue());
1610                         case T_int:
1611                                 return Constant.fromValue(left.longValue() <= right.intValue());
1612                         case T_long:
1613                                 return Constant
1614                                                 .fromValue(left.longValue() <= right.longValue());
1615                         }
1616                 }
1617
1618                 return NotAConstant;
1619         }
1620
1621         public static final Constant computeConstantOperationMINUS(Constant left,
1622                         int leftId, int operator, Constant right, int rightId) {
1623
1624                 switch (leftId) {
1625                 case T_char:
1626                         switch (rightId) {
1627                         case T_char:
1628                                 return Constant.fromValue(left.charValue() - right.charValue());
1629                         case T_float:
1630                                 return Constant
1631                                                 .fromValue(left.charValue() - right.floatValue());
1632                         case T_double:
1633                                 return Constant.fromValue(left.charValue()
1634                                                 - right.doubleValue());
1635                         case T_byte:
1636                                 return Constant.fromValue(left.charValue() - right.byteValue());
1637                         case T_short:
1638                                 return Constant
1639                                                 .fromValue(left.charValue() - right.shortValue());
1640                         case T_int:
1641                                 return Constant.fromValue(left.charValue() - right.intValue());
1642                         case T_long:
1643                                 return Constant.fromValue(left.charValue() - right.longValue());
1644                         }
1645                         break;
1646                 case T_float:
1647                         switch (rightId) {
1648                         case T_char:
1649                                 return Constant
1650                                                 .fromValue(left.floatValue() - right.charValue());
1651                         case T_float:
1652                                 return Constant.fromValue(left.floatValue()
1653                                                 - right.floatValue());
1654                         case T_double:
1655                                 return Constant.fromValue(left.floatValue()
1656                                                 - right.doubleValue());
1657                         case T_byte:
1658                                 return Constant
1659                                                 .fromValue(left.floatValue() - right.byteValue());
1660                         case T_short:
1661                                 return Constant.fromValue(left.floatValue()
1662                                                 - right.shortValue());
1663                         case T_int:
1664                                 return Constant.fromValue(left.floatValue() - right.intValue());
1665                         case T_long:
1666                                 return Constant
1667                                                 .fromValue(left.floatValue() - right.longValue());
1668                         }
1669                         break;
1670                 case T_double:
1671                         switch (rightId) {
1672                         case T_char:
1673                                 return Constant.fromValue(left.doubleValue()
1674                                                 - right.charValue());
1675                         case T_float:
1676                                 return Constant.fromValue(left.doubleValue()
1677                                                 - right.floatValue());
1678                         case T_double:
1679                                 return Constant.fromValue(left.doubleValue()
1680                                                 - right.doubleValue());
1681                         case T_byte:
1682                                 return Constant.fromValue(left.doubleValue()
1683                                                 - right.byteValue());
1684                         case T_short:
1685                                 return Constant.fromValue(left.doubleValue()
1686                                                 - right.shortValue());
1687                         case T_int:
1688                                 return Constant
1689                                                 .fromValue(left.doubleValue() - right.intValue());
1690                         case T_long:
1691                                 return Constant.fromValue(left.doubleValue()
1692                                                 - right.longValue());
1693                         }
1694                         break;
1695                 case T_byte:
1696                         switch (rightId) {
1697                         case T_char:
1698                                 return Constant.fromValue(left.byteValue() - right.charValue());
1699                         case T_float:
1700                                 return Constant
1701                                                 .fromValue(left.byteValue() - right.floatValue());
1702                         case T_double:
1703                                 return Constant.fromValue(left.byteValue()
1704                                                 - right.doubleValue());
1705                         case T_byte:
1706                                 return Constant.fromValue(left.byteValue() - right.byteValue());
1707                         case T_short:
1708                                 return Constant
1709                                                 .fromValue(left.byteValue() - right.shortValue());
1710                         case T_int:
1711                                 return Constant.fromValue(left.byteValue() - right.intValue());
1712                         case T_long:
1713                                 return Constant.fromValue(left.byteValue() - right.longValue());
1714                         }
1715                         break;
1716                 case T_short:
1717                         switch (rightId) {
1718                         case T_char:
1719                                 return Constant
1720                                                 .fromValue(left.shortValue() - right.charValue());
1721                         case T_float:
1722                                 return Constant.fromValue(left.shortValue()
1723                                                 - right.floatValue());
1724                         case T_double:
1725                                 return Constant.fromValue(left.shortValue()
1726                                                 - right.doubleValue());
1727                         case T_byte:
1728                                 return Constant
1729                                                 .fromValue(left.shortValue() - right.byteValue());
1730                         case T_short:
1731                                 return Constant.fromValue(left.shortValue()
1732                                                 - right.shortValue());
1733                         case T_int:
1734                                 return Constant.fromValue(left.shortValue() - right.intValue());
1735                         case T_long:
1736                                 return Constant
1737                                                 .fromValue(left.shortValue() - right.longValue());
1738                         }
1739                         break;
1740                 case T_int:
1741                         switch (rightId) {
1742                         case T_char:
1743                                 return Constant.fromValue(left.intValue() - right.charValue());
1744                         case T_float:
1745                                 return Constant.fromValue(left.intValue() - right.floatValue());
1746                         case T_double:
1747                                 return Constant
1748                                                 .fromValue(left.intValue() - right.doubleValue());
1749                         case T_byte:
1750                                 return Constant.fromValue(left.intValue() - right.byteValue());
1751                         case T_short:
1752                                 return Constant.fromValue(left.intValue() - right.shortValue());
1753                         case T_int:
1754                                 return Constant.fromValue(left.intValue() - right.intValue());
1755                         case T_long:
1756                                 return Constant.fromValue(left.intValue() - right.longValue());
1757                         }
1758                         break;
1759                 case T_long:
1760                         switch (rightId) {
1761                         case T_char:
1762                                 return Constant.fromValue(left.longValue() - right.charValue());
1763                         case T_float:
1764                                 return Constant
1765                                                 .fromValue(left.longValue() - right.floatValue());
1766                         case T_double:
1767                                 return Constant.fromValue(left.longValue()
1768                                                 - right.doubleValue());
1769                         case T_byte:
1770                                 return Constant.fromValue(left.longValue() - right.byteValue());
1771                         case T_short:
1772                                 return Constant
1773                                                 .fromValue(left.longValue() - right.shortValue());
1774                         case T_int:
1775                                 return Constant.fromValue(left.longValue() - right.intValue());
1776                         case T_long:
1777                                 return Constant.fromValue(left.longValue() - right.longValue());
1778                         }
1779
1780                 }
1781
1782                 return NotAConstant;
1783         }
1784
1785         public static final Constant computeConstantOperationMULTIPLY(
1786                         Constant left, int leftId, int operator, Constant right, int rightId) {
1787
1788                 switch (leftId) {
1789                 case T_char:
1790                         switch (rightId) {
1791                         case T_char:
1792                                 return Constant.fromValue(left.charValue() * right.charValue());
1793                         case T_float:
1794                                 return Constant
1795                                                 .fromValue(left.charValue() * right.floatValue());
1796                         case T_double:
1797                                 return Constant.fromValue(left.charValue()
1798                                                 * right.doubleValue());
1799                         case T_byte:
1800                                 return Constant.fromValue(left.charValue() * right.byteValue());
1801                         case T_short:
1802                                 return Constant
1803                                                 .fromValue(left.charValue() * right.shortValue());
1804                         case T_int:
1805                                 return Constant.fromValue(left.charValue() * right.intValue());
1806                         case T_long:
1807                                 return Constant.fromValue(left.charValue() * right.longValue());
1808                         }
1809                         break;
1810                 case T_float:
1811                         switch (rightId) {
1812                         case T_char:
1813                                 return Constant
1814                                                 .fromValue(left.floatValue() * right.charValue());
1815                         case T_float:
1816                                 return Constant.fromValue(left.floatValue()
1817                                                 * right.floatValue());
1818                         case T_double:
1819                                 return Constant.fromValue(left.floatValue()
1820                                                 * right.doubleValue());
1821                         case T_byte:
1822                                 return Constant
1823                                                 .fromValue(left.floatValue() * right.byteValue());
1824                         case T_short:
1825                                 return Constant.fromValue(left.floatValue()
1826                                                 * right.shortValue());
1827                         case T_int:
1828                                 return Constant.fromValue(left.floatValue() * right.intValue());
1829                         case T_long:
1830                                 return Constant
1831                                                 .fromValue(left.floatValue() * right.longValue());
1832                         }
1833                         break;
1834                 case T_double:
1835                         switch (rightId) {
1836                         case T_char:
1837                                 return Constant.fromValue(left.doubleValue()
1838                                                 * right.charValue());
1839                         case T_float:
1840                                 return Constant.fromValue(left.doubleValue()
1841                                                 * right.floatValue());
1842                         case T_double:
1843                                 return Constant.fromValue(left.doubleValue()
1844                                                 * right.doubleValue());
1845                         case T_byte:
1846                                 return Constant.fromValue(left.doubleValue()
1847                                                 * right.byteValue());
1848                         case T_short:
1849                                 return Constant.fromValue(left.doubleValue()
1850                                                 * right.shortValue());
1851                         case T_int:
1852                                 return Constant
1853                                                 .fromValue(left.doubleValue() * right.intValue());
1854                         case T_long:
1855                                 return Constant.fromValue(left.doubleValue()
1856                                                 * right.longValue());
1857                         }
1858                         break;
1859                 case T_byte:
1860                         switch (rightId) {
1861                         case T_char:
1862                                 return Constant.fromValue(left.byteValue() * right.charValue());
1863                         case T_float:
1864                                 return Constant
1865                                                 .fromValue(left.byteValue() * right.floatValue());
1866                         case T_double:
1867                                 return Constant.fromValue(left.byteValue()
1868                                                 * right.doubleValue());
1869                         case T_byte:
1870                                 return Constant.fromValue(left.byteValue() * right.byteValue());
1871                         case T_short:
1872                                 return Constant
1873                                                 .fromValue(left.byteValue() * right.shortValue());
1874                         case T_int:
1875                                 return Constant.fromValue(left.byteValue() * right.intValue());
1876                         case T_long:
1877                                 return Constant.fromValue(left.byteValue() * right.longValue());
1878                         }
1879                         break;
1880                 case T_short:
1881                         switch (rightId) {
1882                         case T_char:
1883                                 return Constant
1884                                                 .fromValue(left.shortValue() * right.charValue());
1885                         case T_float:
1886                                 return Constant.fromValue(left.shortValue()
1887                                                 * right.floatValue());
1888                         case T_double:
1889                                 return Constant.fromValue(left.shortValue()
1890                                                 * right.doubleValue());
1891                         case T_byte:
1892                                 return Constant
1893                                                 .fromValue(left.shortValue() * right.byteValue());
1894                         case T_short:
1895                                 return Constant.fromValue(left.shortValue()
1896                                                 * right.shortValue());
1897                         case T_int:
1898                                 return Constant.fromValue(left.shortValue() * right.intValue());
1899                         case T_long:
1900                                 return Constant
1901                                                 .fromValue(left.shortValue() * right.longValue());
1902                         }
1903                         break;
1904                 case T_int:
1905                         switch (rightId) {
1906                         case T_char:
1907                                 return Constant.fromValue(left.intValue() * right.charValue());
1908                         case T_float:
1909                                 return Constant.fromValue(left.intValue() * right.floatValue());
1910                         case T_double:
1911                                 return Constant
1912                                                 .fromValue(left.intValue() * right.doubleValue());
1913                         case T_byte:
1914                                 return Constant.fromValue(left.intValue() * right.byteValue());
1915                         case T_short:
1916                                 return Constant.fromValue(left.intValue() * right.shortValue());
1917                         case T_int:
1918                                 return Constant.fromValue(left.intValue() * right.intValue());
1919                         case T_long:
1920                                 return Constant.fromValue(left.intValue() * right.longValue());
1921                         }
1922                         break;
1923                 case T_long:
1924                         switch (rightId) {
1925                         case T_char:
1926                                 return Constant.fromValue(left.longValue() * right.charValue());
1927                         case T_float:
1928                                 return Constant
1929                                                 .fromValue(left.longValue() * right.floatValue());
1930                         case T_double:
1931                                 return Constant.fromValue(left.longValue()
1932                                                 * right.doubleValue());
1933                         case T_byte:
1934                                 return Constant.fromValue(left.longValue() * right.byteValue());
1935                         case T_short:
1936                                 return Constant
1937                                                 .fromValue(left.longValue() * right.shortValue());
1938                         case T_int:
1939                                 return Constant.fromValue(left.longValue() * right.intValue());
1940                         case T_long:
1941                                 return Constant.fromValue(left.longValue() * right.longValue());
1942                         }
1943                 }
1944
1945                 return NotAConstant;
1946         }
1947
1948         public static final Constant computeConstantOperationOR(Constant left,
1949                         int leftId, int operator, Constant right, int rightId) {
1950
1951                 switch (leftId) {
1952                 case T_boolean:
1953                         return Constant.fromValue(left.booleanValue()
1954                                         | right.booleanValue());
1955                 case T_char:
1956                         switch (rightId) {
1957                         case T_char:
1958                                 return Constant.fromValue(left.charValue() | right.charValue());
1959                         case T_byte:
1960                                 return Constant.fromValue(left.charValue() | right.byteValue());
1961                         case T_short:
1962                                 return Constant
1963                                                 .fromValue(left.charValue() | right.shortValue());
1964                         case T_int:
1965                                 return Constant.fromValue(left.charValue() | right.intValue());
1966                         case T_long:
1967                                 return Constant.fromValue(left.charValue() | right.longValue());
1968                         }
1969                         break;
1970                 case T_byte:
1971                         switch (rightId) {
1972                         case T_char:
1973                                 return Constant.fromValue(left.byteValue() | right.charValue());
1974                         case T_byte:
1975                                 return Constant.fromValue(left.byteValue() | right.byteValue());
1976                         case T_short:
1977                                 return Constant
1978                                                 .fromValue(left.byteValue() | right.shortValue());
1979                         case T_int:
1980                                 return Constant.fromValue(left.byteValue() | right.intValue());
1981                         case T_long:
1982                                 return Constant.fromValue(left.byteValue() | right.longValue());
1983                         }
1984                         break;
1985                 case T_short:
1986                         switch (rightId) {
1987                         case T_char:
1988                                 return Constant
1989                                                 .fromValue(left.shortValue() | right.charValue());
1990                         case T_byte:
1991                                 return Constant
1992                                                 .fromValue(left.shortValue() | right.byteValue());
1993                         case T_short:
1994                                 return Constant.fromValue(left.shortValue()
1995                                                 | right.shortValue());
1996                         case T_int:
1997                                 return Constant.fromValue(left.shortValue() | right.intValue());
1998                         case T_long:
1999                                 return Constant
2000                                                 .fromValue(left.shortValue() | right.longValue());
2001                         }
2002                         break;
2003                 case T_int:
2004                         switch (rightId) {
2005                         case T_char:
2006                                 return Constant.fromValue(left.intValue() | right.charValue());
2007                         case T_byte:
2008                                 return Constant.fromValue(left.intValue() | right.byteValue());
2009                         case T_short:
2010                                 return Constant.fromValue(left.intValue() | right.shortValue());
2011                         case T_int:
2012                                 return Constant.fromValue(left.intValue() | right.intValue());
2013                         case T_long:
2014                                 return Constant.fromValue(left.intValue() | right.longValue());
2015                         }
2016                         break;
2017                 case T_long:
2018                         switch (rightId) {
2019                         case T_char:
2020                                 return Constant.fromValue(left.longValue() | right.charValue());
2021                         case T_byte:
2022                                 return Constant.fromValue(left.longValue() | right.byteValue());
2023                         case T_short:
2024                                 return Constant
2025                                                 .fromValue(left.longValue() | right.shortValue());
2026                         case T_int:
2027                                 return Constant.fromValue(left.longValue() | right.intValue());
2028                         case T_long:
2029                                 return Constant.fromValue(left.longValue() | right.longValue());
2030                         }
2031
2032                 }
2033
2034                 return NotAConstant;
2035         }
2036
2037         public static final Constant computeConstantOperationOR_OR(Constant left,
2038                         int leftId, int operator, Constant right, int rightId) {
2039
2040                 return Constant.fromValue(left.booleanValue() || right.booleanValue());
2041         }
2042
2043         public static final Constant computeConstantOperationPLUS(Constant left,
2044                         int leftId, int operator, Constant right, int rightId) {
2045
2046                 switch (leftId) {
2047                 case T_Object:
2048                         if (rightId == T_String) {
2049                                 return Constant.fromValue(left.stringValue()
2050                                                 + right.stringValue());
2051                         }
2052                 case T_boolean:
2053                         if (rightId == T_String) {
2054                                 return Constant.fromValue(left.stringValue()
2055                                                 + right.stringValue());
2056                         }
2057                         break;
2058                 case T_char:
2059                         switch (rightId) {
2060                         case T_char:
2061                                 return Constant.fromValue(left.charValue() + right.charValue());
2062                         case T_float:
2063                                 return Constant
2064                                                 .fromValue(left.charValue() + right.floatValue());
2065                         case T_double:
2066                                 return Constant.fromValue(left.charValue()
2067                                                 + right.doubleValue());
2068                         case T_byte:
2069                                 return Constant.fromValue(left.charValue() + right.byteValue());
2070                         case T_short:
2071                                 return Constant
2072                                                 .fromValue(left.charValue() + right.shortValue());
2073                         case T_int:
2074                                 return Constant.fromValue(left.charValue() + right.intValue());
2075                         case T_long:
2076                                 return Constant.fromValue(left.charValue() + right.longValue());
2077                         case T_String:
2078                                 return Constant.fromValue(left.stringValue()
2079                                                 + right.stringValue());
2080                         }
2081                         break;
2082                 case T_float:
2083                         switch (rightId) {
2084                         case T_char:
2085                                 return Constant
2086                                                 .fromValue(left.floatValue() + right.charValue());
2087                         case T_float:
2088                                 return Constant.fromValue(left.floatValue()
2089                                                 + right.floatValue());
2090                         case T_double:
2091                                 return Constant.fromValue(left.floatValue()
2092                                                 + right.doubleValue());
2093                         case T_byte:
2094                                 return Constant
2095                                                 .fromValue(left.floatValue() + right.byteValue());
2096                         case T_short:
2097                                 return Constant.fromValue(left.floatValue()
2098                                                 + right.shortValue());
2099                         case T_int:
2100                                 return Constant.fromValue(left.floatValue() + right.intValue());
2101                         case T_long:
2102                                 return Constant
2103                                                 .fromValue(left.floatValue() + right.longValue());
2104                         case T_String:
2105                                 return Constant.fromValue(left.stringValue()
2106                                                 + right.stringValue());
2107                         }
2108                         break;
2109                 case T_double:
2110                         switch (rightId) {
2111                         case T_char:
2112                                 return Constant.fromValue(left.doubleValue()
2113                                                 + right.charValue());
2114                         case T_float:
2115                                 return Constant.fromValue(left.doubleValue()
2116                                                 + right.floatValue());
2117                         case T_double:
2118                                 return Constant.fromValue(left.doubleValue()
2119                                                 + right.doubleValue());
2120                         case T_byte:
2121                                 return Constant.fromValue(left.doubleValue()
2122                                                 + right.byteValue());
2123                         case T_short:
2124                                 return Constant.fromValue(left.doubleValue()
2125                                                 + right.shortValue());
2126                         case T_int:
2127                                 return Constant
2128                                                 .fromValue(left.doubleValue() + right.intValue());
2129                         case T_long:
2130                                 return Constant.fromValue(left.doubleValue()
2131                                                 + right.longValue());
2132                         case T_String:
2133                                 return Constant.fromValue(left.stringValue()
2134                                                 + right.stringValue());
2135                         }
2136                         break;
2137                 case T_byte:
2138                         switch (rightId) {
2139                         case T_char:
2140                                 return Constant.fromValue(left.byteValue() + right.charValue());
2141                         case T_float:
2142                                 return Constant
2143                                                 .fromValue(left.byteValue() + right.floatValue());
2144                         case T_double:
2145                                 return Constant.fromValue(left.byteValue()
2146                                                 + right.doubleValue());
2147                         case T_byte:
2148                                 return Constant.fromValue(left.byteValue() + right.byteValue());
2149                         case T_short:
2150                                 return Constant
2151                                                 .fromValue(left.byteValue() + right.shortValue());
2152                         case T_int:
2153                                 return Constant.fromValue(left.byteValue() + right.intValue());
2154                         case T_long:
2155                                 return Constant.fromValue(left.byteValue() + right.longValue());
2156                         case T_String:
2157                                 return Constant.fromValue(left.stringValue()
2158                                                 + right.stringValue());
2159                         }
2160
2161                         break;
2162                 case T_short:
2163                         switch (rightId) {
2164                         case T_char:
2165                                 return Constant
2166                                                 .fromValue(left.shortValue() + right.charValue());
2167                         case T_float:
2168                                 return Constant.fromValue(left.shortValue()
2169                                                 + right.floatValue());
2170                         case T_double:
2171                                 return Constant.fromValue(left.shortValue()
2172                                                 + right.doubleValue());
2173                         case T_byte:
2174                                 return Constant
2175                                                 .fromValue(left.shortValue() + right.byteValue());
2176                         case T_short:
2177                                 return Constant.fromValue(left.shortValue()
2178                                                 + right.shortValue());
2179                         case T_int:
2180                                 return Constant.fromValue(left.shortValue() + right.intValue());
2181                         case T_long:
2182                                 return Constant
2183                                                 .fromValue(left.shortValue() + right.longValue());
2184                         case T_String:
2185                                 return Constant.fromValue(left.stringValue()
2186                                                 + right.stringValue());
2187                         }
2188                         break;
2189                 case T_int:
2190                         switch (rightId) {
2191                         case T_char:
2192                                 return Constant.fromValue(left.intValue() + right.charValue());
2193                         case T_float:
2194                                 return Constant.fromValue(left.intValue() + right.floatValue());
2195                         case T_double:
2196                                 return Constant
2197                                                 .fromValue(left.intValue() + right.doubleValue());
2198                         case T_byte:
2199                                 return Constant.fromValue(left.intValue() + right.byteValue());
2200                         case T_short:
2201                                 return Constant.fromValue(left.intValue() + right.shortValue());
2202                         case T_int:
2203                                 return Constant.fromValue(left.intValue() + right.intValue());
2204                         case T_long:
2205                                 return Constant.fromValue(left.intValue() + right.longValue());
2206                         case T_String:
2207                                 return Constant.fromValue(left.stringValue()
2208                                                 + right.stringValue());
2209                         }
2210                         break;
2211                 case T_long:
2212                         switch (rightId) {
2213                         case T_char:
2214                                 return Constant.fromValue(left.longValue() + right.charValue());
2215                         case T_float:
2216                                 return Constant
2217                                                 .fromValue(left.longValue() + right.floatValue());
2218                         case T_double:
2219                                 return Constant.fromValue(left.longValue()
2220                                                 + right.doubleValue());
2221                         case T_byte:
2222                                 return Constant.fromValue(left.longValue() + right.byteValue());
2223                         case T_short:
2224                                 return Constant
2225                                                 .fromValue(left.longValue() + right.shortValue());
2226                         case T_int:
2227                                 return Constant.fromValue(left.longValue() + right.intValue());
2228                         case T_long:
2229                                 return Constant.fromValue(left.longValue() + right.longValue());
2230                         case T_String:
2231                                 return Constant.fromValue(left.stringValue()
2232                                                 + right.stringValue());
2233                         }
2234                         break;
2235                 case T_String:
2236                         switch (rightId) {
2237                         case T_char:
2238                                 return Constant.fromValue(left.stringValue()
2239                                                 + right.stringValue());
2240                         case T_float:
2241                                 return Constant.fromValue(left.stringValue()
2242                                                 + right.stringValue());
2243                         case T_double:
2244                                 return Constant.fromValue(left.stringValue()
2245                                                 + right.stringValue());
2246                         case T_byte:
2247                                 return Constant.fromValue(left.stringValue()
2248                                                 + right.stringValue());
2249                         case T_short:
2250                                 return Constant.fromValue(left.stringValue()
2251                                                 + right.stringValue());
2252                         case T_int:
2253                                 return Constant.fromValue(left.stringValue()
2254                                                 + right.stringValue());
2255                         case T_long:
2256                                 return Constant.fromValue(left.stringValue()
2257                                                 + right.stringValue());
2258                         case T_String:
2259                                 return Constant.fromValue(left.stringValue()
2260                                                 + right.stringValue());
2261                         case T_boolean:
2262                                 return Constant.fromValue(left.stringValue()
2263                                                 + right.stringValue());
2264                         }
2265                         break;
2266                 case T_null:
2267                         switch (rightId) {
2268                         case T_char:
2269                                 return Constant.fromValue(left.stringValue()
2270                                                 + right.stringValue());
2271                         case T_float:
2272                                 return Constant.fromValue(left.stringValue()
2273                                                 + right.stringValue());
2274                         case T_double:
2275                                 return Constant.fromValue(left.stringValue()
2276                                                 + right.stringValue());
2277                         case T_byte:
2278                                 return Constant.fromValue(left.stringValue()
2279                                                 + right.stringValue());
2280                         case T_short:
2281                                 return Constant.fromValue(left.stringValue()
2282                                                 + right.stringValue());
2283                         case T_int:
2284                                 return Constant.fromValue(left.stringValue()
2285                                                 + right.stringValue());
2286                         case T_long:
2287                                 return Constant.fromValue(left.stringValue()
2288                                                 + right.stringValue());
2289                         case T_String:
2290                                 return Constant.fromValue(left.stringValue()
2291                                                 + right.stringValue());
2292                         }
2293
2294                 }
2295
2296                 return NotAConstant;
2297         }
2298
2299         public static final Constant computeConstantOperationREMAINDER(
2300                         Constant left, int leftId, int operator, Constant right, int rightId) {
2301
2302                 switch (leftId) {
2303                 case T_char:
2304                         switch (rightId) {
2305                         case T_char:
2306                                 return Constant.fromValue(left.charValue() % right.charValue());
2307                         case T_float:
2308                                 return Constant
2309                                                 .fromValue(left.charValue() % right.floatValue());
2310                         case T_double:
2311                                 return Constant.fromValue(left.charValue()
2312                                                 % right.doubleValue());
2313                         case T_byte:
2314                                 return Constant.fromValue(left.charValue() % right.byteValue());
2315                         case T_short:
2316                                 return Constant
2317                                                 .fromValue(left.charValue() % right.shortValue());
2318                         case T_int:
2319                                 return Constant.fromValue(left.charValue() % right.intValue());
2320                         case T_long:
2321                                 return Constant.fromValue(left.charValue() % right.longValue());
2322                         }
2323                         break;
2324                 case T_float:
2325                         switch (rightId) {
2326                         case T_char:
2327                                 return Constant
2328                                                 .fromValue(left.floatValue() % right.charValue());
2329                         case T_float:
2330                                 return Constant.fromValue(left.floatValue()
2331                                                 % right.floatValue());
2332                         case T_double:
2333                                 return Constant.fromValue(left.floatValue()
2334                                                 % right.doubleValue());
2335                         case T_byte:
2336                                 return Constant
2337                                                 .fromValue(left.floatValue() % right.byteValue());
2338                         case T_short:
2339                                 return Constant.fromValue(left.floatValue()
2340                                                 % right.shortValue());
2341                         case T_int:
2342                                 return Constant.fromValue(left.floatValue() % right.intValue());
2343                         case T_long:
2344                                 return Constant
2345                                                 .fromValue(left.floatValue() % right.longValue());
2346                         }
2347                         break;
2348                 case T_double:
2349                         switch (rightId) {
2350                         case T_char:
2351                                 return Constant.fromValue(left.doubleValue()
2352                                                 % right.charValue());
2353                         case T_float:
2354                                 return Constant.fromValue(left.doubleValue()
2355                                                 % right.floatValue());
2356                         case T_double:
2357                                 return Constant.fromValue(left.doubleValue()
2358                                                 % right.doubleValue());
2359                         case T_byte:
2360                                 return Constant.fromValue(left.doubleValue()
2361                                                 % right.byteValue());
2362                         case T_short:
2363                                 return Constant.fromValue(left.doubleValue()
2364                                                 % right.shortValue());
2365                         case T_int:
2366                                 return Constant
2367                                                 .fromValue(left.doubleValue() % right.intValue());
2368                         case T_long:
2369                                 return Constant.fromValue(left.doubleValue()
2370                                                 % right.longValue());
2371                         }
2372                         break;
2373                 case T_byte:
2374                         switch (rightId) {
2375                         case T_char:
2376                                 return Constant.fromValue(left.byteValue() % right.charValue());
2377                         case T_float:
2378                                 return Constant
2379                                                 .fromValue(left.byteValue() % right.floatValue());
2380                         case T_double:
2381                                 return Constant.fromValue(left.byteValue()
2382                                                 % right.doubleValue());
2383                         case T_byte:
2384                                 return Constant.fromValue(left.byteValue() % right.byteValue());
2385                         case T_short:
2386                                 return Constant
2387                                                 .fromValue(left.byteValue() % right.shortValue());
2388                         case T_int:
2389                                 return Constant.fromValue(left.byteValue() % right.intValue());
2390                         case T_long:
2391                                 return Constant.fromValue(left.byteValue() % right.longValue());
2392                         }
2393                         break;
2394                 case T_short:
2395                         switch (rightId) {
2396                         case T_char:
2397                                 return Constant
2398                                                 .fromValue(left.shortValue() % right.charValue());
2399                         case T_float:
2400                                 return Constant.fromValue(left.shortValue()
2401                                                 % right.floatValue());
2402                         case T_double:
2403                                 return Constant.fromValue(left.shortValue()
2404                                                 % right.doubleValue());
2405                         case T_byte:
2406                                 return Constant
2407                                                 .fromValue(left.shortValue() % right.byteValue());
2408                         case T_short:
2409                                 return Constant.fromValue(left.shortValue()
2410                                                 % right.shortValue());
2411                         case T_int:
2412                                 return Constant.fromValue(left.shortValue() % right.intValue());
2413                         case T_long:
2414                                 return Constant
2415                                                 .fromValue(left.shortValue() % right.longValue());
2416                         }
2417                         break;
2418                 case T_int:
2419                         switch (rightId) {
2420                         case T_char:
2421                                 return Constant.fromValue(left.intValue() % right.charValue());
2422                         case T_float:
2423                                 return Constant.fromValue(left.intValue() % right.floatValue());
2424                         case T_double:
2425                                 return Constant
2426                                                 .fromValue(left.intValue() % right.doubleValue());
2427                         case T_byte:
2428                                 return Constant.fromValue(left.intValue() % right.byteValue());
2429                         case T_short:
2430                                 return Constant.fromValue(left.intValue() % right.shortValue());
2431                         case T_int:
2432                                 return Constant.fromValue(left.intValue() % right.intValue());
2433                         case T_long:
2434                                 return Constant.fromValue(left.intValue() % right.longValue());
2435                         }
2436                         break;
2437                 case T_long:
2438                         switch (rightId) {
2439                         case T_char:
2440                                 return Constant.fromValue(left.longValue() % right.charValue());
2441                         case T_float:
2442                                 return Constant
2443                                                 .fromValue(left.longValue() % right.floatValue());
2444                         case T_double:
2445                                 return Constant.fromValue(left.longValue()
2446                                                 % right.doubleValue());
2447                         case T_byte:
2448                                 return Constant.fromValue(left.longValue() % right.byteValue());
2449                         case T_short:
2450                                 return Constant
2451                                                 .fromValue(left.longValue() % right.shortValue());
2452                         case T_int:
2453                                 return Constant.fromValue(left.longValue() % right.intValue());
2454                         case T_long:
2455                                 return Constant.fromValue(left.longValue() % right.longValue());
2456                         }
2457
2458                 }
2459
2460                 return NotAConstant;
2461         }
2462
2463         public static final Constant computeConstantOperationRIGHT_SHIFT(
2464                         Constant left, int leftId, int operator, Constant right, int rightId) {
2465
2466                 switch (leftId) {
2467                 case T_char:
2468                         switch (rightId) {
2469                         case T_char:
2470                                 return Constant
2471                                                 .fromValue(left.charValue() >> right.charValue());
2472                         case T_byte:
2473                                 return Constant
2474                                                 .fromValue(left.charValue() >> right.byteValue());
2475                         case T_short:
2476                                 return Constant.fromValue(left.charValue() >> right
2477                                                 .shortValue());
2478                         case T_int:
2479                                 return Constant.fromValue(left.charValue() >> right.intValue());
2480                         case T_long:
2481                                 return Constant
2482                                                 .fromValue(left.charValue() >> right.longValue());
2483                         }
2484                         break;
2485                 case T_byte:
2486                         switch (rightId) {
2487                         case T_char:
2488                                 return Constant
2489                                                 .fromValue(left.byteValue() >> right.charValue());
2490                         case T_byte:
2491                                 return Constant
2492                                                 .fromValue(left.byteValue() >> right.byteValue());
2493                         case T_short:
2494                                 return Constant.fromValue(left.byteValue() >> right
2495                                                 .shortValue());
2496                         case T_int:
2497                                 return Constant.fromValue(left.byteValue() >> right.intValue());
2498                         case T_long:
2499                                 return Constant
2500                                                 .fromValue(left.byteValue() >> right.longValue());
2501                         }
2502                         break;
2503                 case T_short:
2504                         switch (rightId) {
2505                         case T_char:
2506                                 return Constant.fromValue(left.shortValue() >> right
2507                                                 .charValue());
2508                         case T_byte:
2509                                 return Constant.fromValue(left.shortValue() >> right
2510                                                 .byteValue());
2511                         case T_short:
2512                                 return Constant.fromValue(left.shortValue() >> right
2513                                                 .shortValue());
2514                         case T_int:
2515                                 return Constant
2516                                                 .fromValue(left.shortValue() >> right.intValue());
2517                         case T_long:
2518                                 return Constant.fromValue(left.shortValue() >> right
2519                                                 .longValue());
2520                         }
2521                         break;
2522                 case T_int:
2523                         switch (rightId) {
2524                         case T_char:
2525                                 return Constant.fromValue(left.intValue() >> right.charValue());
2526                         case T_byte:
2527                                 return Constant.fromValue(left.intValue() >> right.byteValue());
2528                         case T_short:
2529                                 return Constant
2530                                                 .fromValue(left.intValue() >> right.shortValue());
2531                         case T_int:
2532                                 return Constant.fromValue(left.intValue() >> right.intValue());
2533                         case T_long:
2534                                 return Constant.fromValue(left.intValue() >> right.longValue());
2535                         }
2536                         break;
2537                 case T_long:
2538                         switch (rightId) {
2539                         case T_char:
2540                                 return Constant
2541                                                 .fromValue(left.longValue() >> right.charValue());
2542                         case T_byte:
2543                                 return Constant
2544                                                 .fromValue(left.longValue() >> right.byteValue());
2545                         case T_short:
2546                                 return Constant.fromValue(left.longValue() >> right
2547                                                 .shortValue());
2548                         case T_int:
2549                                 return Constant.fromValue(left.longValue() >> right.intValue());
2550                         case T_long:
2551                                 return Constant
2552                                                 .fromValue(left.longValue() >> right.longValue());
2553                         }
2554
2555                 }
2556
2557                 return NotAConstant;
2558         }
2559
2560         public static final Constant computeConstantOperationUNSIGNED_RIGHT_SHIFT(
2561                         Constant left, int leftId, int operator, Constant right, int rightId) {
2562
2563                 switch (leftId) {
2564                 case T_char:
2565                         switch (rightId) {
2566                         case T_char:
2567                                 return Constant.fromValue(left.charValue() >>> right
2568                                                 .charValue());
2569                         case T_byte:
2570                                 return Constant.fromValue(left.charValue() >>> right
2571                                                 .byteValue());
2572                         case T_short:
2573                                 return Constant.fromValue(left.charValue() >>> right
2574                                                 .shortValue());
2575                         case T_int:
2576                                 return Constant
2577                                                 .fromValue(left.charValue() >>> right.intValue());
2578                         case T_long:
2579                                 return Constant.fromValue(left.charValue() >>> right
2580                                                 .longValue());
2581                         }
2582                         break;
2583                 case T_byte:
2584                         switch (rightId) {
2585                         case T_char:
2586                                 return Constant.fromValue(left.byteValue() >>> right
2587                                                 .charValue());
2588                         case T_byte:
2589                                 return Constant.fromValue(left.byteValue() >>> right
2590                                                 .byteValue());
2591                         case T_short:
2592                                 return Constant.fromValue(left.byteValue() >>> right
2593                                                 .shortValue());
2594                         case T_int:
2595                                 return Constant
2596                                                 .fromValue(left.byteValue() >>> right.intValue());
2597                         case T_long:
2598                                 return Constant.fromValue(left.byteValue() >>> right
2599                                                 .longValue());
2600                         }
2601                         break;
2602                 case T_short:
2603                         switch (rightId) {
2604                         case T_char:
2605                                 return Constant.fromValue(left.shortValue() >>> right
2606                                                 .charValue());
2607                         case T_byte:
2608                                 return Constant.fromValue(left.shortValue() >>> right
2609                                                 .byteValue());
2610                         case T_short:
2611                                 return Constant.fromValue(left.shortValue() >>> right
2612                                                 .shortValue());
2613                         case T_int:
2614                                 return Constant.fromValue(left.shortValue() >>> right
2615                                                 .intValue());
2616                         case T_long:
2617                                 return Constant.fromValue(left.shortValue() >>> right
2618                                                 .longValue());
2619                         }
2620                         break;
2621                 case T_int:
2622                         switch (rightId) {
2623                         case T_char:
2624                                 return Constant
2625                                                 .fromValue(left.intValue() >>> right.charValue());
2626                         case T_byte:
2627                                 return Constant
2628                                                 .fromValue(left.intValue() >>> right.byteValue());
2629                         case T_short:
2630                                 return Constant.fromValue(left.intValue() >>> right
2631                                                 .shortValue());
2632                         case T_int:
2633                                 return Constant.fromValue(left.intValue() >>> right.intValue());
2634                         case T_long:
2635                                 return Constant
2636                                                 .fromValue(left.intValue() >>> right.longValue());
2637                         }
2638                         break;
2639                 case T_long:
2640                         switch (rightId) {
2641                         case T_char:
2642                                 return Constant.fromValue(left.longValue() >>> right
2643                                                 .charValue());
2644                         case T_byte:
2645                                 return Constant.fromValue(left.longValue() >>> right
2646                                                 .byteValue());
2647                         case T_short:
2648                                 return Constant.fromValue(left.longValue() >>> right
2649                                                 .shortValue());
2650                         case T_int:
2651                                 return Constant
2652                                                 .fromValue(left.longValue() >>> right.intValue());
2653                         case T_long:
2654                                 return Constant.fromValue(left.longValue() >>> right
2655                                                 .longValue());
2656                         }
2657
2658                 }
2659
2660                 return NotAConstant;
2661         }
2662
2663         public static final Constant computeConstantOperationXOR(Constant left,
2664                         int leftId, int operator, Constant right, int rightId) {
2665
2666                 switch (leftId) {
2667                 case T_boolean:
2668                         return Constant.fromValue(left.booleanValue()
2669                                         ^ right.booleanValue());
2670                 case T_char:
2671                         switch (rightId) {
2672                         case T_char:
2673                                 return Constant.fromValue(left.charValue() ^ right.charValue());
2674                         case T_byte:
2675                                 return Constant.fromValue(left.charValue() ^ right.byteValue());
2676                         case T_short:
2677                                 return Constant
2678                                                 .fromValue(left.charValue() ^ right.shortValue());
2679                         case T_int:
2680                                 return Constant.fromValue(left.charValue() ^ right.intValue());
2681                         case T_long:
2682                                 return Constant.fromValue(left.charValue() ^ right.longValue());
2683                         }
2684                         break;
2685                 case T_byte:
2686                         switch (rightId) {
2687                         case T_char:
2688                                 return Constant.fromValue(left.byteValue() ^ right.charValue());
2689                         case T_byte:
2690                                 return Constant.fromValue(left.byteValue() ^ right.byteValue());
2691                         case T_short:
2692                                 return Constant
2693                                                 .fromValue(left.byteValue() ^ right.shortValue());
2694                         case T_int:
2695                                 return Constant.fromValue(left.byteValue() ^ right.intValue());
2696                         case T_long:
2697                                 return Constant.fromValue(left.byteValue() ^ right.longValue());
2698                         }
2699                         break;
2700                 case T_short:
2701                         switch (rightId) {
2702                         case T_char:
2703                                 return Constant
2704                                                 .fromValue(left.shortValue() ^ right.charValue());
2705                         case T_byte:
2706                                 return Constant
2707                                                 .fromValue(left.shortValue() ^ right.byteValue());
2708                         case T_short:
2709                                 return Constant.fromValue(left.shortValue()
2710                                                 ^ right.shortValue());
2711                         case T_int:
2712                                 return Constant.fromValue(left.shortValue() ^ right.intValue());
2713                         case T_long:
2714                                 return Constant
2715                                                 .fromValue(left.shortValue() ^ right.longValue());
2716                         }
2717                         break;
2718                 case T_int:
2719                         switch (rightId) {
2720                         case T_char:
2721                                 return Constant.fromValue(left.intValue() ^ right.charValue());
2722                         case T_byte:
2723                                 return Constant.fromValue(left.intValue() ^ right.byteValue());
2724                         case T_short:
2725                                 return Constant.fromValue(left.intValue() ^ right.shortValue());
2726                         case T_int:
2727                                 return Constant.fromValue(left.intValue() ^ right.intValue());
2728                         case T_long:
2729                                 return Constant.fromValue(left.intValue() ^ right.longValue());
2730                         }
2731                         break;
2732                 case T_long:
2733                         switch (rightId) {
2734                         case T_char:
2735                                 return Constant.fromValue(left.longValue() ^ right.charValue());
2736                         case T_byte:
2737                                 return Constant.fromValue(left.longValue() ^ right.byteValue());
2738                         case T_short:
2739                                 return Constant
2740                                                 .fromValue(left.longValue() ^ right.shortValue());
2741                         case T_int:
2742                                 return Constant.fromValue(left.longValue() ^ right.intValue());
2743                         case T_long:
2744                                 return Constant.fromValue(left.longValue() ^ right.longValue());
2745                         }
2746                 }
2747
2748                 return NotAConstant;
2749         }
2750
2751         public double doubleValue() {
2752
2753                 throw new ShouldNotImplement(Util.bind(
2754                                 "constant.cannotCastedInto", typeName(), "double")); //$NON-NLS-2$ //$NON-NLS-1$
2755         }
2756
2757         public float floatValue() {
2758
2759                 throw new ShouldNotImplement(Util.bind(
2760                                 "constant.cannotCastedInto", typeName(), "float")); //$NON-NLS-2$ //$NON-NLS-1$
2761         }
2762
2763         // public static Constant fromValue(byte value) {
2764         //
2765         // return new ByteConstant(value);
2766         // }
2767
2768         // public static Constant fromValue(char value) {
2769         //
2770         // return new CharConstant(value);
2771         // }
2772
2773         public static Constant fromValue(double value) {
2774
2775                 return new DoubleConstant(value);
2776         }
2777
2778         // public static Constant fromValue(float value) {
2779         //
2780         // return new FloatConstant(value);
2781         // }
2782
2783         public static Constant fromValue(int value) {
2784
2785                 return new IntConstant(value);
2786         }
2787
2788         // public static Constant fromValue(long value) {
2789         //
2790         // return new LongConstant(value);
2791         // }
2792
2793         public static Constant fromValue(String value) {
2794
2795                 return new StringConstant(value);
2796         }
2797
2798         // public static Constant fromValue(short value) {
2799         //
2800         // return new ShortConstant(value);
2801         // }
2802
2803         public static Constant fromValue(boolean value) {
2804
2805                 return new BooleanConstant(value);
2806         }
2807
2808         public int intValue() {
2809
2810                 throw new ShouldNotImplement(Util.bind(
2811                                 "constant.cannotCastedInto", typeName(), "int")); //$NON-NLS-2$ //$NON-NLS-1$
2812         }
2813
2814         public long longValue() {
2815
2816                 throw new ShouldNotImplement(Util.bind(
2817                                 "constant.cannotCastedInto", typeName(), "long")); //$NON-NLS-2$ //$NON-NLS-1$
2818         }
2819
2820         public short shortValue() {
2821
2822                 throw new ShouldNotImplement(Util.bind(
2823                                 "constant.cannotConvertedTo", typeName(), "short")); //$NON-NLS-2$ //$NON-NLS-1$
2824         }
2825
2826         public String stringValue() {
2827
2828                 throw new ShouldNotImplement(Util.bind(
2829                                 "constant.cannotConvertedTo", typeName(), "String")); //$NON-NLS-1$ //$NON-NLS-2$
2830         }
2831
2832         public String toString() {
2833
2834                 if (this == NotAConstant)
2835                         return "(Constant) NotAConstant"; //$NON-NLS-1$
2836                 return super.toString();
2837         }
2838
2839         public abstract int typeID();
2840
2841         public String typeName() {
2842                 switch (typeID()) {
2843                 case T_int:
2844                         return "int"; //$NON-NLS-1$
2845                 case T_byte:
2846                         return "byte"; //$NON-NLS-1$
2847                 case T_short:
2848                         return "short"; //$NON-NLS-1$
2849                 case T_char:
2850                         return "char"; //$NON-NLS-1$
2851                 case T_float:
2852                         return "float"; //$NON-NLS-1$
2853                 case T_double:
2854                         return "double"; //$NON-NLS-1$
2855                 case T_boolean:
2856                         return "boolean"; //$NON-NLS-1$
2857                 case T_long:
2858                         return "long";//$NON-NLS-1$
2859                 case T_String:
2860                         return "java.lang.String"; //$NON-NLS-1$
2861                 case T_null:
2862                         return "null"; //$NON-NLS-1$
2863                 default:
2864                         return "unknown"; //$NON-NLS-1$
2865                 }
2866         }
2867 }