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