Start the debugger through setting the url with "?DBGSESSID=1@clienthost:10001" in...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / internal / compiler / ast / Expression.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.phpeclipse.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
14 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
15 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
16 import net.sourceforge.phpdt.internal.compiler.lookup.BaseTypeBinding;
17 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
18 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
19
20 public class Expression extends Statement {
21         
22         //some expression may not be used - from a java semantic point
23         //of view only - as statements. Other may. In order to avoid the creation
24         //of wrappers around expression in order to tune them as expression
25         //Expression is a subclass of Statement. See the message isValidJavaStatement()
26
27         public int implicitConversion;
28         public TypeBinding resolvedType;
29         
30         public Constant constant;
31
32         public Expression() {
33                 super();
34         }
35
36         public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
37
38                 return flowInfo;
39         }
40
41         public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
42
43                 return analyseCode(currentScope, flowContext, flowInfo);
44         }
45
46         /**
47          * Constant usable for bytecode pattern optimizations, but cannot be inlined
48          * since it is not strictly equivalent to the definition of constant expressions.
49          * In particular, some side-effects may be required to occur (only the end value
50          * is known).
51          * Constant is known to be of boolean type
52          */ 
53         public Constant optimizedBooleanConstant() {
54
55                 return this.constant;
56         }
57
58         public static final boolean isConstantValueRepresentable(
59                 Constant constant,
60                 int constantTypeID,
61                 int targetTypeID) {
62
63                 //true if there is no loss of precision while casting.
64                 // constantTypeID == constant.typeID
65                 if (targetTypeID == constantTypeID)
66                         return true;
67                 switch (targetTypeID) {
68                         case T_char :
69                                 switch (constantTypeID) {
70                                         case T_char :
71                                                 return true;
72                                         case T_double :
73                                                 return constant.doubleValue() == constant.charValue();
74                                         case T_float :
75                                                 return constant.floatValue() == constant.charValue();
76                                         case T_int :
77                                                 return constant.intValue() == constant.charValue();
78                                         case T_short :
79                                                 return constant.shortValue() == constant.charValue();
80                                         case T_byte :
81                                                 return constant.byteValue() == constant.charValue();
82                                         case T_long :
83                                                 return constant.longValue() == constant.charValue();
84                                         default :
85                                                 return false;//boolean
86                                 } 
87
88                         case T_float :
89                                 switch (constantTypeID) {
90                                         case T_char :
91                                                 return constant.charValue() == constant.floatValue();
92                                         case T_double :
93                                                 return constant.doubleValue() == constant.floatValue();
94                                         case T_float :
95                                                 return true;
96                                         case T_int :
97                                                 return constant.intValue() == constant.floatValue();
98                                         case T_short :
99                                                 return constant.shortValue() == constant.floatValue();
100                                         case T_byte :
101                                                 return constant.byteValue() == constant.floatValue();
102                                         case T_long :
103                                                 return constant.longValue() == constant.floatValue();
104                                         default :
105                                                 return false;//boolean
106                                 } 
107                                 
108                         case T_double :
109                                 switch (constantTypeID) {
110                                         case T_char :
111                                                 return constant.charValue() == constant.doubleValue();
112                                         case T_double :
113                                                 return true;
114                                         case T_float :
115                                                 return constant.floatValue() == constant.doubleValue();
116                                         case T_int :
117                                                 return constant.intValue() == constant.doubleValue();
118                                         case T_short :
119                                                 return constant.shortValue() == constant.doubleValue();
120                                         case T_byte :
121                                                 return constant.byteValue() == constant.doubleValue();
122                                         case T_long :
123                                                 return constant.longValue() == constant.doubleValue();
124                                         default :
125                                                 return false; //boolean
126                                 } 
127                                 
128                         case T_byte :
129                                 switch (constantTypeID) {
130                                         case T_char :
131                                                 return constant.charValue() == constant.byteValue();
132                                         case T_double :
133                                                 return constant.doubleValue() == constant.byteValue();
134                                         case T_float :
135                                                 return constant.floatValue() == constant.byteValue();
136                                         case T_int :
137                                                 return constant.intValue() == constant.byteValue();
138                                         case T_short :
139                                                 return constant.shortValue() == constant.byteValue();
140                                         case T_byte :
141                                                 return true;
142                                         case T_long :
143                                                 return constant.longValue() == constant.byteValue();
144                                         default :
145                                                 return false; //boolean
146                                 } 
147                                 
148                         case T_short :
149                                 switch (constantTypeID) {
150                                         case T_char :
151                                                 return constant.charValue() == constant.shortValue();
152                                         case T_double :
153                                                 return constant.doubleValue() == constant.shortValue();
154                                         case T_float :
155                                                 return constant.floatValue() == constant.shortValue();
156                                         case T_int :
157                                                 return constant.intValue() == constant.shortValue();
158                                         case T_short :
159                                                 return true;
160                                         case T_byte :
161                                                 return constant.byteValue() == constant.shortValue();
162                                         case T_long :
163                                                 return constant.longValue() == constant.shortValue();
164                                         default :
165                                                 return false; //boolean
166                                 } 
167                                 
168                         case T_int :
169                                 switch (constantTypeID) {
170                                         case T_char :
171                                                 return constant.charValue() == constant.intValue();
172                                         case T_double :
173                                                 return constant.doubleValue() == constant.intValue();
174                                         case T_float :
175                                                 return constant.floatValue() == constant.intValue();
176                                         case T_int :
177                                                 return true;
178                                         case T_short :
179                                                 return constant.shortValue() == constant.intValue();
180                                         case T_byte :
181                                                 return constant.byteValue() == constant.intValue();
182                                         case T_long :
183                                                 return constant.longValue() == constant.intValue();
184                                         default :
185                                                 return false; //boolean
186                                 } 
187                                 
188                         case T_long :
189                                 switch (constantTypeID) {
190                                         case T_char :
191                                                 return constant.charValue() == constant.longValue();
192                                         case T_double :
193                                                 return constant.doubleValue() == constant.longValue();
194                                         case T_float :
195                                                 return constant.floatValue() == constant.longValue();
196                                         case T_int :
197                                                 return constant.intValue() == constant.longValue();
198                                         case T_short :
199                                                 return constant.shortValue() == constant.longValue();
200                                         case T_byte :
201                                                 return constant.byteValue() == constant.longValue();
202                                         case T_long :
203                                                 return true;
204                                         default :
205                                                 return false; //boolean
206                                 } 
207                                 
208                         default :
209                                 return false; //boolean
210                 } 
211         }
212
213         /**
214          * Expression statements are plain expressions, however they generate like
215          * normal expressions with no value required.
216          *
217          * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
218          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream 
219          */
220 //      public void generateCode(BlockScope currentScope, CodeStream codeStream) {
221 //
222 //              if ((bits & IsReachableMASK) == 0) {
223 //                      return;
224 //              }
225 //              generateCode(currentScope, codeStream, false);
226 //      }
227
228         /**
229          * Every expression is responsible for generating its implicit conversion when necessary.
230          *
231          * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
232          * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
233          * @param valueRequired boolean
234          */
235 //      public void generateCode(
236 //              BlockScope currentScope,
237 //              CodeStream codeStream,
238 //              boolean valueRequired) {
239 //
240 //              if (constant != NotAConstant) {
241 //                      // generate a constant expression
242 //                      int pc = codeStream.position;
243 //                      codeStream.generateConstant(constant, implicitConversion);
244 //                      codeStream.recordPositionsFrom(pc, this.sourceStart);
245 //              } else {
246 //                      // actual non-constant code generation
247 //                      throw new ShouldNotImplement(ProjectPrefUtil.bind("ast.missingCode")); //$NON-NLS-1$
248 //              }
249 //      }
250
251         /**
252          * Default generation of a boolean value
253          */
254 //      public void generateOptimizedBoolean(
255 //              BlockScope currentScope,
256 //              CodeStream codeStream,
257 //              Label trueLabel,
258 //              Label falseLabel,
259 //              boolean valueRequired) {
260 //
261 //              // a label valued to nil means: by default we fall through the case... 
262 //              // both nil means we leave the value on the stack
263 //
264 //              if ((constant != Constant.NotAConstant) && (constant.typeID() == T_boolean)) {
265 //                      int pc = codeStream.position;
266 //                      if (constant.booleanValue() == true) {
267 //                              // constant == true
268 //                              if (valueRequired) {
269 //                                      if (falseLabel == null) {
270 //                                              // implicit falling through the FALSE case
271 //                                              if (trueLabel != null) {
272 //                                                      codeStream.goto_(trueLabel);
273 //                                              }
274 //                                      }
275 //                              }
276 //                      } else {
277 //                              if (valueRequired) {
278 //                                      if (falseLabel != null) {
279 //                                              // implicit falling through the TRUE case
280 //                                              if (trueLabel == null) {
281 //                                                      codeStream.goto_(falseLabel);
282 //                                              }
283 //                                      }
284 //                              }
285 //                      }
286 //                      codeStream.recordPositionsFrom(pc, this.sourceStart);
287 //                      return;
288 //              }
289 //              generateCode(currentScope, codeStream, valueRequired);
290 //              // branching
291 //              int position = codeStream.position;
292 //              if (valueRequired) {
293 //                      if (falseLabel == null) {
294 //                              if (trueLabel != null) {
295 //                                      // Implicit falling through the FALSE case
296 //                                      codeStream.ifne(trueLabel);
297 //                              }
298 //                      } else {
299 //                              if (trueLabel == null) {
300 //                                      // Implicit falling through the TRUE case
301 //                                      codeStream.ifeq(falseLabel);
302 //                              } else {
303 //                                      // No implicit fall through TRUE/FALSE --> should never occur
304 //                              }
305 //                      }
306 //              }
307 //              // reposition the endPC
308 //              codeStream.updateLastRecordedEndPC(position);
309 //      }
310 //
311 //      /* Optimized (java) code generation for string concatenations that involve StringBuffer
312 //       * creation: going through this path means that there is no need for a new StringBuffer
313 //       * creation, further operands should rather be only appended to the current one.
314 //       * By default: no optimization.
315 //       */
316 //      public void generateOptimizedStringBuffer(
317 //              BlockScope blockScope,
318 //              org.eclipse.jdt.internal.compiler.codegen.CodeStream codeStream,
319 //              int typeID) {
320 //
321 //              generateCode(blockScope, codeStream, true);
322 //              codeStream.invokeStringBufferAppendForType(typeID);
323 //      }
324
325         /* Optimized (java) code generation for string concatenations that involve StringBuffer
326          * creation: going through this path means that there is no need for a new StringBuffer
327          * creation, further operands should rather be only appended to the current one.
328          */
329 //      public void generateOptimizedStringBufferCreation(
330 //              BlockScope blockScope,
331 //              CodeStream codeStream,
332 //              int typeID) {
333 //
334 //              // Optimization only for integers and strings
335 //              if (typeID == T_Object) {
336 //                      // in the case the runtime value of valueOf(Object) returns null, we have to use append(Object) instead of directly valueOf(Object)
337 //                      // append(Object) returns append(valueOf(Object)), which means that the null case is handled by append(String).
338 //                      codeStream.newStringBuffer();
339 //                      codeStream.dup();
340 //                      codeStream.invokeStringBufferDefaultConstructor();
341 //                      generateCode(blockScope, codeStream, true);
342 //                      codeStream.invokeStringBufferAppendForType(T_Object);
343 //                      return;
344 //              }
345 //              codeStream.newStringBuffer();
346 //              codeStream.dup();
347 //              if (typeID == T_String || typeID == T_null) {
348 //                      if (constant != NotAConstant) {
349 //                              codeStream.ldc(constant.stringValue());
350 //                      } else {
351 //                              generateCode(blockScope, codeStream, true);
352 //                              codeStream.invokeStringValueOf(T_Object);
353 //                      }
354 //              } else {
355 //                      generateCode(blockScope, codeStream, true);
356 //                      codeStream.invokeStringValueOf(typeID);
357 //              }
358 //              codeStream.invokeStringBufferStringConstructor();
359 //      }
360
361         // Base types need that the widening is explicitly done by the compiler using some bytecode like i2f
362         public void implicitWidening(
363                 TypeBinding runtimeTimeType,
364                 TypeBinding compileTimeType) {
365
366                 if (runtimeTimeType == null || compileTimeType == null)
367                         return;
368
369 //              if (compileTimeType.id == T_null) {
370 //                      // this case is possible only for constant null
371 //                      // The type of runtime is a reference type
372 //                      // The code gen use the constant id thus any value
373 //                      // for the runtime id (akak the <<4) could be used.
374 //                      // T_Object is used as some general T_reference
375 //                      implicitConversion = (T_Object << 4) + T_null;
376 //                      return;
377 //              }
378
379                 switch (runtimeTimeType.id) {
380                         case T_byte :
381                         case T_short :
382                         case T_char :
383                                 implicitConversion = (T_int << 4) + compileTimeType.id;
384                                 break;
385                         case T_String :
386                         case T_float :
387                         case T_boolean :
388                         case T_double :
389                         case T_int : //implicitConversion may result in i2i which will result in NO code gen
390                         case T_long :
391                                 implicitConversion = (runtimeTimeType.id << 4) + compileTimeType.id;
392                                 break;
393                         default : //nothing on regular object ref
394                 }
395         }
396
397         public boolean isCompactableOperation() {
398
399                 return false;
400         }
401
402         //Return true if the conversion is done AUTOMATICALLY by the vm
403         //while the javaVM is an int based-machine, thus for example pushing
404         //a byte onto the stack , will automatically creates a int on the stack
405         //(this request some work d be done by the VM on signed numbers)
406         public boolean isConstantValueOfTypeAssignableToType(
407                 TypeBinding constantType,
408                 TypeBinding targetType) {
409
410                 if (constant == Constant.NotAConstant)
411                         return false;
412                 if (constantType == targetType)
413                         return true;
414                 if (constantType.isBaseType() && targetType.isBaseType()) {
415                         //No free assignment conversion from anything but to integral ones.
416                         if ((constantType == IntBinding
417                                 || BaseTypeBinding.isWidening(T_int, constantType.id))
418                                 && (BaseTypeBinding.isNarrowing(targetType.id, T_int))) {
419                                 //use current explicit conversion in order to get some new value to compare with current one
420                                 return isConstantValueRepresentable(constant, constantType.id, targetType.id);
421                         }
422                 }
423                 return false;
424         }
425
426         public boolean isTypeReference() {
427                 return false;
428         }
429
430         public void resolve(BlockScope scope) {
431                 // drops the returning expression's type whatever the type is.
432
433                 this.resolveType(scope);
434                 return;
435         }
436
437         public TypeBinding resolveType(BlockScope scope) {
438                 // by default... subclasses should implement a better TC if required.
439
440                 return null;
441         }
442
443         public TypeBinding resolveTypeExpecting(
444                 BlockScope scope,
445                 TypeBinding expectedType) {
446
447                 TypeBinding expressionType = this.resolveType(scope);
448                 if (expressionType == null) return null;
449                 if (expressionType == expectedType) return expressionType;
450                 
451                 if (!expressionType.isCompatibleWith(expectedType)) {
452                         scope.problemReporter().typeMismatchError(expressionType, expectedType, this);
453                         return null;
454                 }
455                 return expressionType;
456         }
457
458         public String toString(int tab) {
459
460                 //Subclass re-define toStringExpression
461                 String s = tabString(tab);
462                 if (constant != null)
463                         //before TC has runned
464                         if (constant != NotAConstant)
465                                 //after the TC has runned
466                                 s += " /*cst:" + constant.toString() + "*/ "; //$NON-NLS-1$ //$NON-NLS-2$
467                 return s + toStringExpression(tab);
468         }
469
470         //Subclass re-define toStringExpression
471         //This method is abstract and should never be called
472         //but we provide some code that is running.....just in case
473         //of developpement time (while every  thing is not built)
474         public String toStringExpression() {
475
476                 return super.toString(0);
477         }
478
479         public String toStringExpression(int tab) {
480                 // default is regular toString expression (qualified allocation expressions redifine this method)
481                 return this.toStringExpression();
482         }
483
484         public Expression toTypeReference() {
485                 //by default undefined
486
487                 //this method is meanly used by the parser in order to transform
488                 //an expression that is used as a type reference in a cast ....
489                 //--appreciate the fact that castExpression and ExpressionWithParenthesis
490                 //--starts with the same pattern.....
491
492                 return this;
493         }
494 }