Removed some internal constants
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / internal / compiler / ast / AbstractMethodDeclaration.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.core.compiler.CharOperation;
14 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
15 import net.sourceforge.phpdt.internal.compiler.CompilationResult;
16 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
17 import net.sourceforge.phpdt.internal.compiler.flow.InitializationFlowContext;
18 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
19 import net.sourceforge.phpdt.internal.compiler.lookup.ClassScope;
20 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
21 import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
22 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
23 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
24 import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
25 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
26 import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilationUnit;
27 import net.sourceforge.phpdt.internal.compiler.problem.AbortMethod;
28 import net.sourceforge.phpdt.internal.compiler.problem.AbortType;
29 import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities;
30
31
32 public abstract class AbstractMethodDeclaration
33         extends ASTNode
34         implements ProblemSeverities, ReferenceContext {
35                 
36         public MethodScope scope;
37         //it is not relevent for constructor but it helps to have the name of the constructor here 
38         //which is always the name of the class.....parsing do extra work to fill it up while it do not have to....
39         public char[] selector;
40         public int declarationSourceStart;
41         public int declarationSourceEnd;
42         public int modifiers;
43         public int modifiersSourceStart;
44         public Argument[] arguments;
45         public TypeReference[] thrownExceptions;
46         public Statement[] statements;
47         public int explicitDeclarations;
48         public MethodBinding binding;
49         public boolean ignoreFurtherInvestigation = false;
50         public boolean needFreeReturn = false;
51         
52         public int bodyStart;
53         public int bodyEnd = -1;
54         public CompilationResult compilationResult;
55         
56         AbstractMethodDeclaration(CompilationResult compilationResult){
57                 this.compilationResult = compilationResult;
58         }
59         
60         /*
61          *      We cause the compilation task to abort to a given extent.
62          */
63         public void abort(int abortLevel) {
64
65                 if (scope == null) {
66                         throw new AbortCompilation(); // cannot do better
67                 }
68
69                 CompilationResult compilationResult =
70                         scope.referenceCompilationUnit().compilationResult;
71
72                 switch (abortLevel) {
73                         case AbortCompilation :
74                                 throw new AbortCompilation(compilationResult);
75                         case AbortCompilationUnit :
76                                 throw new AbortCompilationUnit(compilationResult);
77                         case AbortType :
78                                 throw new AbortType(compilationResult);
79                         default :
80                                 throw new AbortMethod(compilationResult);
81                 }
82         }
83
84         public abstract void analyseCode(ClassScope scope, InitializationFlowContext initializationContext, FlowInfo info);
85
86                 /**
87          * Bind and add argument's binding into the scope of the method
88          */
89         public void bindArguments() {
90
91                 if (arguments != null) {
92                         // by default arguments in abstract/native methods are considered to be used (no complaint is expected)
93                         boolean used = binding == null || binding.isAbstract();// || binding.isNative();
94
95                         int length = arguments.length;
96                         for (int i = 0; i < length; i++) {
97                                 TypeBinding argType = binding == null ? null : binding.parameters[i];
98                                 arguments[i].bind(scope, argType, used);
99                         }
100                 }
101         }
102
103         /**
104          * Record the thrown exception type bindings in the corresponding type references.
105          */
106         public void bindThrownExceptions() {
107
108                 if (this.thrownExceptions != null
109                         && this.binding != null
110                         && this.binding.thrownExceptions != null) {
111                         int thrownExceptionLength = this.thrownExceptions.length;
112                         int length = this.binding.thrownExceptions.length;
113                         if (length == thrownExceptionLength) {
114                                 for (int i = 0; i < length; i++) {
115                                         this.thrownExceptions[i].resolvedType = this.binding.thrownExceptions[i];
116                                 }
117                         } else {
118                                 int bindingIndex = 0;
119                                 for (int i = 0; i < thrownExceptionLength && bindingIndex < length; i++) {
120                                         TypeReference thrownException = this.thrownExceptions[i];
121                                         ReferenceBinding thrownExceptionBinding = this.binding.thrownExceptions[bindingIndex];
122                                         char[][] bindingCompoundName = thrownExceptionBinding.compoundName;
123                                         if (thrownException instanceof SingleTypeReference) {
124                                                 // single type reference
125                                                 int lengthName = bindingCompoundName.length;
126                                                 char[] thrownExceptionTypeName = thrownException.getTypeName()[0];
127                                                 if (CharOperation.equals(thrownExceptionTypeName, bindingCompoundName[lengthName - 1])) {
128                                                         thrownException.resolvedType = thrownExceptionBinding;
129                                                         bindingIndex++;
130                                                 }
131                                         } else {
132                                                 // qualified type reference
133                                                 if (CharOperation.equals(thrownException.getTypeName(), bindingCompoundName)) {
134                                                         thrownException.resolvedType = thrownExceptionBinding;
135                                                         bindingIndex++;
136                                                 }                                               
137                                         }
138                                 }
139                         }
140                 }
141         }
142
143         public CompilationResult compilationResult() {
144                 
145                 return this.compilationResult;
146         }
147         
148         /**
149          * Bytecode generation for a method
150          */
151 //      public void generateCode(ClassScope classScope, ClassFile classFile) {
152 //              
153 //              int problemResetPC = 0;
154 //              classFile.codeStream.wideMode = false; // reset wideMode to false
155 //              if (ignoreFurtherInvestigation) {
156 //                      // method is known to have errors, dump a problem method
157 //                      if (this.binding == null)
158 //                              return; // handle methods with invalid signature or duplicates
159 //                      int problemsLength;
160 //                      IProblem[] problems =
161 //                              scope.referenceCompilationUnit().compilationResult.getProblems();
162 //                      IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
163 //                      System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
164 //                      classFile.addProblemMethod(this, binding, problemsCopy);
165 //                      return;
166 //              }
167 //              // regular code generation
168 //              try {
169 //                      problemResetPC = classFile.contentsOffset;
170 //                      this.generateCode(classFile);
171 //              } catch (AbortMethod e) {
172 //                      // a fatal error was detected during code generation, need to restart code gen if possible
173 //                      if (e.compilationResult == CodeStream.RESTART_IN_WIDE_MODE) {
174 //                              // a branch target required a goto_w, restart code gen in wide mode.
175 //                              try {
176 //                                      this.traverse(new ResetStateForCodeGenerationVisitor(), classScope);
177 //                                      classFile.contentsOffset = problemResetPC;
178 //                                      classFile.methodCount--;
179 //                                      classFile.codeStream.wideMode = true; // request wide mode 
180 //                                      this.generateCode(classFile); // restart method generation
181 //                              } catch (AbortMethod e2) {
182 //                                      int problemsLength;
183 //                                      IProblem[] problems =
184 //                                              scope.referenceCompilationUnit().compilationResult.getAllProblems();
185 //                                      IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
186 //                                      System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
187 //                                      classFile.addProblemMethod(this, binding, problemsCopy, problemResetPC);
188 //                              }
189 //                      } else {
190 //                              // produce a problem method accounting for this fatal error
191 //                              int problemsLength;
192 //                              IProblem[] problems =
193 //                                      scope.referenceCompilationUnit().compilationResult.getAllProblems();
194 //                              IProblem[] problemsCopy = new IProblem[problemsLength = problems.length];
195 //                              System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
196 //                              classFile.addProblemMethod(this, binding, problemsCopy, problemResetPC);
197 //                      }
198 //              }
199 //      }
200 //
201 //      private void generateCode(ClassFile classFile) {
202 //
203 //              classFile.generateMethodInfoHeader(binding);
204 //              int methodAttributeOffset = classFile.contentsOffset;
205 //              int attributeNumber = classFile.generateMethodInfoAttribute(binding);
206 //              if ((!binding.isNative()) && (!binding.isAbstract())) {
207 //                      int codeAttributeOffset = classFile.contentsOffset;
208 //                      classFile.generateCodeAttributeHeader();
209 //                      CodeStream codeStream = classFile.codeStream;
210 //                      codeStream.reset(this, classFile);
211 //                      // initialize local positions
212 //                      this.scope.computeLocalVariablePositions(binding.isStatic() ? 0 : 1, codeStream);
213 //
214 //                      // arguments initialization for local variable debug attributes
215 //                      if (arguments != null) {
216 //                              for (int i = 0, max = arguments.length; i < max; i++) {
217 //                                      LocalVariableBinding argBinding;
218 //                                      codeStream.addVisibleLocalVariable(argBinding = arguments[i].binding);
219 //                                      argBinding.recordInitializationStartPC(0);
220 //                              }
221 //                      }
222 //                      if (statements != null) {
223 //                              for (int i = 0, max = statements.length; i < max; i++)
224 //                                      statements[i].generateCode(scope, codeStream);
225 //                      }
226 //                      if (this.needFreeReturn) {
227 //                              codeStream.return_();
228 //                      }
229 //                      // local variable attributes
230 //                      codeStream.exitUserScope(scope);
231 //                      codeStream.recordPositionsFrom(0, this.declarationSourceEnd);
232 //                      classFile.completeCodeAttribute(codeAttributeOffset);
233 //                      attributeNumber++;
234 //              } else {
235 //                      checkArgumentsSize();
236 //              }
237 //              classFile.completeMethodInfo(methodAttributeOffset, attributeNumber);
238 //
239 //              // if a problem got reported during code gen, then trigger problem method creation
240 //              if (ignoreFurtherInvestigation) {
241 //                      throw new AbortMethod(scope.referenceCompilationUnit().compilationResult);
242 //              }
243 //      }
244
245 //      private void checkArgumentsSize() {
246 //              TypeBinding[] parameters = binding.parameters;
247 //              int size = 1; // an abstact method or a native method cannot be static
248 //              for (int i = 0, max = parameters.length; i < max; i++) {
249 //                      TypeBinding parameter = parameters[i];
250 //                      if (parameter == LongBinding || parameter == DoubleBinding) {
251 //                              size += 2;
252 //                      } else {
253 //                              size++;
254 //                      }
255 //                      if (size > 0xFF) {
256 //                              scope.problemReporter().noMoreAvailableSpaceForArgument(scope.locals[i], scope.locals[i].declaration);
257 //                      }
258 //              }
259 //      }
260         
261         public boolean hasErrors() {
262                 return this.ignoreFurtherInvestigation;
263         }
264
265         public boolean isAbstract() {
266
267                 if (binding != null)
268                         return binding.isAbstract();
269                 return (modifiers & AccAbstract) != 0;
270         }
271
272         public boolean isClinit() {
273
274                 return false;
275         }
276
277         public boolean isConstructor() {
278
279                 return false;
280         }
281
282         public boolean isDefaultConstructor() {
283
284                 return false;
285         }
286
287         public boolean isInitializationMethod() {
288
289                 return false;
290         }
291
292 //      public boolean isNative() {
293 //
294 //              if (binding != null)
295 //                      return binding.isNative(); 
296 //              return (modifiers & AccNative) != 0;
297 //      }
298
299         public boolean isStatic() {
300
301                 if (binding != null)
302                         return binding.isStatic();
303                 return (modifiers & AccStatic) != 0;
304         }
305
306         /**
307          * Fill up the method body with statement
308          */
309         public abstract void parseStatements(
310                 UnitParser parser,
311                 CompilationUnitDeclaration unit);
312         public StringBuffer print(int tab, StringBuffer output) {
313
314                 printIndent(tab, output);
315                 printModifiers(this.modifiers, output);
316                 printReturnType(0, output).append(this.selector).append('(');
317                 if (this.arguments != null) {
318                         for (int i = 0; i < this.arguments.length; i++) {
319                                 if (i > 0) output.append(", "); //$NON-NLS-1$
320                                 this.arguments[i].print(0, output);
321                         }
322                 }
323                 output.append(')');
324                 if (this.thrownExceptions != null) {
325                         output.append(" throws "); //$NON-NLS-1$
326                         for (int i = 0; i < this.thrownExceptions.length; i++) {
327                                 if (i > 0) output.append(", "); //$NON-NLS-1$
328                                 this.thrownExceptions[i].print(0, output);
329                         }
330                 }
331                 printBody(tab + 1, output);
332                 return output;
333         }
334
335         public StringBuffer printBody(int indent, StringBuffer output) {
336
337                 if (isAbstract() || (this.modifiers & AccSemicolonBody) != 0) 
338                         return output.append(';');
339
340                 output.append(" {"); //$NON-NLS-1$
341                 if (this.statements != null) {
342                         for (int i = 0; i < this.statements.length; i++) {
343                                 output.append('\n');
344                                 this.statements[i].printStatement(indent, output); 
345                         }
346                 }
347                 output.append('\n'); //$NON-NLS-1$
348                 printIndent(indent == 0 ? 0 : indent - 1, output).append('}');
349                 return output;
350         }
351
352         public StringBuffer printReturnType(int indent, StringBuffer output) {
353                 
354                 return output;
355         }
356         public void resolve(ClassScope upperScope) {
357
358                 if (binding == null) {
359                         ignoreFurtherInvestigation = true;
360                 }
361
362                 try {
363                         bindArguments(); 
364                         bindThrownExceptions();
365                         resolveStatements();
366                 } catch (AbortMethod e) {       // ========= abort on fatal error =============
367                         this.ignoreFurtherInvestigation = true;
368                 } 
369         }
370
371         public void resolveStatements() {
372
373                 if (statements != null) {
374                         int i = 0, length = statements.length;
375                         while (i < length)
376                                 statements[i++].resolve(scope);
377                 }
378         }
379
380         public String returnTypeToString(int tab) {
381
382                 return ""; //$NON-NLS-1$
383         }
384
385         public void tagAsHavingErrors() {
386
387                 ignoreFurtherInvestigation = true;
388         }
389
390         public String toString(int tab) {
391
392                 String s = tabString(tab);
393                 if (modifiers != AccDefault) {
394                         s += modifiersString(modifiers);
395                 }
396
397                 s += returnTypeToString(0);
398                 s += new String(selector) + "("; //$NON-NLS-1$
399                 if (arguments != null) {
400                         for (int i = 0; i < arguments.length; i++) {
401                                 s += arguments[i].toString(0);
402                                 if (i != (arguments.length - 1))
403                                         s = s + ", "; //$NON-NLS-1$
404                         };
405                 };
406                 s += ")"; //$NON-NLS-1$
407                 if (thrownExceptions != null) {
408                         s += " throws "; //$NON-NLS-1$
409                         for (int i = 0; i < thrownExceptions.length; i++) {
410                                 s += thrownExceptions[i].toString(0);
411                                 if (i != (thrownExceptions.length - 1))
412                                         s = s + ", "; //$NON-NLS-1$
413                         };
414                 };
415
416                 s += toStringStatements(tab + 1);
417                 return s;
418         }
419
420         public String toStringStatements(int tab) {
421
422                 if (isAbstract() || (this.modifiers & AccSemicolonBody) != 0)
423                         return ";"; //$NON-NLS-1$
424
425                 String s = " {"; //$NON-NLS-1$
426                 if (statements != null) {
427                         for (int i = 0; i < statements.length; i++) {
428                                 s = s + "\n" + statements[i].toString(tab); //$NON-NLS-1$
429                                 if (!(statements[i] instanceof Block)) {
430                                         s += ";"; //$NON-NLS-1$
431                                 }
432                         }
433                 }
434                 s += "\n" + tabString(tab == 0 ? 0 : tab - 1) + "}"; //$NON-NLS-2$ //$NON-NLS-1$
435                 return s;
436         }
437
438         public void traverse(
439             ASTVisitor visitor,
440                 ClassScope classScope) {
441         }
442 }