Some javadoc added
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / LocalDeclaration.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.ast;
12
13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
14 import net.sourceforge.phpdt.internal.compiler.impl.*;
15 import net.sourceforge.phpdt.internal.compiler.codegen.*;
16 import net.sourceforge.phpdt.internal.compiler.flow.*;
17 import net.sourceforge.phpdt.internal.compiler.lookup.*;
18
19 public class LocalDeclaration extends AbstractVariableDeclaration {
20
21         public LocalVariableBinding binding;
22
23         public LocalDeclaration(
24                 Expression expr,
25                 char[] name,
26                 int sourceStart,
27                 int sourceEnd) {
28
29                 initialization = expr;
30                 this.name = name;
31                 this.sourceStart = sourceStart;
32                 this.sourceEnd = sourceEnd;
33                 if (initialization != null) {
34                         this.declarationSourceEnd = initialization.sourceEnd;
35                 } else {
36                         this.declarationSourceEnd = sourceEnd;
37                 }
38                 this.declarationEnd = this.declarationSourceEnd;
39         }
40
41         public FlowInfo analyseCode(
42                 BlockScope currentScope,
43                 FlowContext flowContext,
44                 FlowInfo flowInfo) {
45
46                 // record variable initialization if any
47                 if (!flowInfo.isDeadEnd() && !flowInfo.isFakeReachable()) {
48                         bits |= IsLocalDeclarationReachableMASK; // only set if actually reached
49                 }
50                 if (initialization == null)
51                         return flowInfo;
52                 flowInfo =
53                         initialization
54                                 .analyseCode(currentScope, flowContext, flowInfo)
55                                 .unconditionalInits();
56                 flowInfo.markAsDefinitelyAssigned(binding);
57                 return flowInfo;
58         }
59
60         public void checkModifiers() {
61                 //only potential valid modifier is <<final>>
62
63                 if (((modifiers & AccJustFlag) | AccFinal) != AccFinal)
64                         //AccModifierProblem -> other (non-visibility problem)
65                         //AccAlternateModifierProblem -> duplicate modifier
66                         //AccModifierProblem | AccAlternateModifierProblem -> visibility problem"
67                         // -x-1 returns the bitInvert 
68
69                         modifiers =
70                                 (modifiers & (-AccAlternateModifierProblem - 1)) | AccModifierProblem;
71         }
72
73         /**
74          * Code generation for a local declaration:
75          *      i.e.&nbsp;normal assignment to a local variable + unused variable handling 
76          */
77         public void generateCode(BlockScope currentScope, CodeStream codeStream) {
78
79                 if ((bits & IsReachableMASK) == 0) {
80                         return;
81                 }
82                 int pc = codeStream.position;
83                 Constant inlinedValue;
84                 // something to initialize?
85                 if (binding.resolvedPosition != -1) {
86                         codeStream.addVisibleLocalVariable(binding);
87                 }
88                 if (initialization != null) {
89                         // initialize to constant value?
90                         if ((inlinedValue = initialization.constant) != NotAConstant) {
91                                 // forget initializing unused or final locals set to constant value (final ones are inlined)
92                                 if (binding.resolvedPosition != -1) { // may need to preserve variable
93                                         int initPC = codeStream.position;
94                                         codeStream.generateConstant(inlinedValue, initialization.implicitConversion);
95                                         codeStream.recordPositionsFrom(initPC, initialization.sourceStart);
96                                         codeStream.store(binding, false);
97                                         binding.recordInitializationStartPC(codeStream.position);
98                                         //                              codeStream.lastInitStateIndexWhenRemovingInits = -2; // reinitialize remove index 
99                                         //                              codeStream.lastInitStateIndexWhenAddingInits = -2; // reinitialize add index            
100                                 }
101                         } else { // initializing to non-constant value
102                                 initialization.generateCode(currentScope, codeStream, true);
103                                 // if binding unused generate then discard the value
104                                 if (binding.resolvedPosition != -1) {
105                                         codeStream.store(binding, false);
106                                         if (binding.initializationCount == 0) {
107                                                 /* Variable may have been initialized during the code initializing it
108                                                         e.g. int i = (i = 1);
109                                                 */
110                                                 binding.recordInitializationStartPC(codeStream.position);
111                                                 //                                      codeStream.lastInitStateIndexWhenRemovingInits = -2; // reinitialize remove index 
112                                                 //                                      codeStream.lastInitStateIndexWhenAddingInits = -2; // reinitialize add index 
113                                         }
114                                 } else {
115                                         if ((binding.type == LongBinding) || (binding.type == DoubleBinding)) {
116                                                 codeStream.pop2();
117                                         } else {
118                                                 codeStream.pop();
119                                         }
120                                 }
121                         }
122                 }
123                 codeStream.recordPositionsFrom(pc, this.sourceStart);
124         }
125
126         public String name() {
127
128                 return String.valueOf(name);
129         }
130
131         public void resolve(BlockScope scope) {
132
133                 // create a binding and add it to the scope
134                 TypeBinding tb = type.resolveType(scope);
135
136                 checkModifiers();
137
138                 if (tb != null) {
139                         if (tb == VoidBinding) {
140                                 scope.problemReporter().variableTypeCannotBeVoid(this);
141                                 return;
142                         }
143                         if (tb.isArrayType() && ((ArrayBinding) tb).leafComponentType == VoidBinding) {
144                                 scope.problemReporter().variableTypeCannotBeVoidArray(this);
145                                 return;
146                         }
147                 }
148
149                 // duplicate checks
150                 if ((binding = scope.duplicateName(name)) != null) {
151                         // the name already exists... may carry on with the first binding...
152                         scope.problemReporter().redefineLocal(this);
153                 } else {
154                         binding = new LocalVariableBinding(this, tb, modifiers, false);
155                         scope.addLocalVariable(binding);
156                         binding.constant = NotAConstant;
157                         // allow to recursivelly target the binding....
158                         // the correct constant is harmed if correctly computed at the end of this method
159                 }
160
161                 if (tb == null) {
162                         if (initialization != null)
163                                 initialization.resolveType(scope); // want to report all possible errors
164                         return;
165                 }
166
167                 // store the constant for final locals  
168                 if (initialization != null) {
169                         if (initialization instanceof ArrayInitializer) {
170                                 TypeBinding initTb = initialization.resolveTypeExpecting(scope, tb);
171                                 if (initTb != null) {
172                                         ((ArrayInitializer) initialization).binding = (ArrayBinding) initTb;
173                                         initialization.implicitWidening(tb, initTb);
174                                 }
175                         } else {
176                                 TypeBinding initTb = initialization.resolveType(scope);
177                                 if (initTb != null) {
178                                         if (initialization.isConstantValueOfTypeAssignableToType(initTb, tb)
179                                                 || (tb.isBaseType() && BaseTypeBinding.isWidening(tb.id, initTb.id))
180                                                 || scope.areTypesCompatible(initTb, tb))
181                                                 initialization.implicitWidening(tb, initTb);
182                                         else
183                                                 scope.problemReporter().typeMismatchError(initTb, tb, this);
184                                 }
185                         }
186
187                         // change the constant in the binding when it is final
188                         // (the optimization of the constant propagation will be done later on)
189                         // cast from constant actual type to variable type
190                         binding.constant =
191                                 binding.isFinal()
192                                         ? initialization.constant.castTo((tb.id << 4) + initialization.constant.typeID())
193                                         : NotAConstant;
194                 }
195         }
196
197         public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
198
199                 if (visitor.visit(this, scope)) {
200                         type.traverse(visitor, scope);
201                         if (initialization != null)
202                                 initialization.traverse(visitor, scope);
203                 }
204                 visitor.endVisit(this, scope);
205         }
206 }