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