--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package net.sourceforge.phpdt.internal.compiler.ast;
+
+import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
+import net.sourceforge.phpdt.internal.compiler.codegen.Label;
+import net.sourceforge.phpdt.internal.compiler.flow.ExceptionHandlingFlowContext;
+import net.sourceforge.phpdt.internal.compiler.flow.FinallyFlowContext;
+import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
+import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
+import net.sourceforge.phpdt.internal.compiler.flow.InsideSubRoutineFlowContext;
+import net.sourceforge.phpdt.internal.compiler.flow.UnconditionalFlowInfo;
+import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
+import net.sourceforge.phpdt.internal.compiler.lookup.LocalVariableBinding;
+import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
+import net.sourceforge.phpdt.internal.compiler.lookup.MethodScope;
+import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
+import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
+
+public class TryStatement extends Statement {
+
+ public Block tryBlock;
+ public Block[] catchBlocks;
+ public Argument[] catchArguments;
+ public Block finallyBlock;
+ BlockScope scope;
+
+ public boolean subRoutineCannotReturn = true;
+ public UnconditionalFlowInfo subRoutineInits;
+
+ // should rename into subRoutineComplete to be set to false by default
+
+ ReferenceBinding[] caughtExceptionTypes;
+ boolean tryBlockExit;
+ boolean[] catchExits;
+ public int[] preserveExceptionHandler;
+
+ Label subRoutineStartLabel;
+ public LocalVariableBinding anyExceptionVariable,
+ returnAddressVariable,
+ secretReturnValue;
+
+ public final static char[] SecretReturnName = " returnAddress".toCharArray(); //$NON-NLS-1$
+ public final static char[] SecretAnyHandlerName = " anyExceptionHandler".toCharArray(); //$NON-NLS-1$
+ public static final char[] SecretLocalDeclarationName = " returnValue".toCharArray(); //$NON-NLS-1$
+
+ // for local variables table attributes
+ int preTryInitStateIndex = -1;
+ int mergedInitStateIndex = -1;
+
+ public FlowInfo analyseCode(
+ BlockScope currentScope,
+ FlowContext flowContext,
+ FlowInfo flowInfo) {
+
+ // Consider the try block and catch block so as to compute the intersection of initializations and
+ // the minimum exit relative depth amongst all of them. Then consider the subroutine, and append its
+ // initialization to the try/catch ones, if the subroutine completes normally. If the subroutine does not
+ // complete, then only keep this result for the rest of the analysis
+
+ // process the finally block (subroutine) - create a context for the subroutine
+
+ preTryInitStateIndex =
+ currentScope.methodScope().recordInitializationStates(flowInfo);
+
+ if (anyExceptionVariable != null) {
+ anyExceptionVariable.useFlag = LocalVariableBinding.USED;
+ }
+ if (returnAddressVariable != null) {
+ returnAddressVariable.useFlag = LocalVariableBinding.USED;
+ }
+ InsideSubRoutineFlowContext insideSubContext;
+ FinallyFlowContext finallyContext;
+ UnconditionalFlowInfo subInfo;
+ if (subRoutineStartLabel == null) {
+ // no finally block
+ insideSubContext = null;
+ finallyContext = null;
+ subInfo = null;
+ } else {
+ // analyse finally block first
+ insideSubContext = new InsideSubRoutineFlowContext(flowContext, this);
+ subInfo =
+ finallyBlock
+ .analyseCode(
+ currentScope,
+ finallyContext = new FinallyFlowContext(flowContext, finallyBlock),
+ flowInfo.copy())
+ .unconditionalInits();
+ if (subInfo.isReachable()) {
+ subRoutineCannotReturn = false;
+ }
+ this.subRoutineInits = subInfo;
+ }
+ // process the try block in a context handling the local exceptions.
+ ExceptionHandlingFlowContext handlingContext =
+ new ExceptionHandlingFlowContext(
+ insideSubContext == null ? flowContext : insideSubContext,
+ tryBlock,
+ caughtExceptionTypes,
+ scope,
+ flowInfo.unconditionalInits());
+
+ FlowInfo tryInfo;
+ if (tryBlock.statements == null) {
+ tryInfo = flowInfo;
+ tryBlockExit = false;
+ } else {
+ tryInfo = tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
+ tryBlockExit = !tryInfo.isReachable();
+ }
+
+ // check unreachable catch blocks
+// handlingContext.complainIfUnusedExceptionHandlers(catchBlocks, scope, this);
+
+ // process the catch blocks - computing the minimal exit depth amongst try/catch
+ if (catchArguments != null) {
+ int catchCount;
+ catchExits = new boolean[catchCount = catchBlocks.length];
+ for (int i = 0; i < catchCount; i++) {
+ // keep track of the inits that could potentially have led to this exception handler (for final assignments diagnosis)
+ FlowInfo catchInfo =
+ flowInfo
+ .copy()
+ .unconditionalInits()
+ .addPotentialInitializationsFrom(
+ handlingContext.initsOnException(caughtExceptionTypes[i]).unconditionalInits())
+ .addPotentialInitializationsFrom(tryInfo.unconditionalInits())
+ .addPotentialInitializationsFrom(handlingContext.initsOnReturn);
+
+ // catch var is always set
+ catchInfo.markAsDefinitelyAssigned(catchArguments[i].binding);
+ /*
+ "If we are about to consider an unchecked exception handler, potential inits may have occured inside
+ the try block that need to be detected , e.g.
+ try { x = 1; throwSomething();} catch(Exception e){ x = 2} "
+ "(uncheckedExceptionTypes notNil and: [uncheckedExceptionTypes at: index])
+ ifTrue: [catchInits addPotentialInitializationsFrom: tryInits]."
+ */
+ // TODO: should only tag as unreachable if the catchblock cannot be reached
+ //??? if (!handlingContext.initsOnException(caughtExceptionTypes[i]).isReachable()){
+ if (tryBlock.statements == null) {
+ catchInfo.setReachMode(FlowInfo.UNREACHABLE);
+ }
+ catchInfo =
+ catchBlocks[i].analyseCode(
+ currentScope,
+ insideSubContext == null ? flowContext : insideSubContext,
+ catchInfo);
+ catchExits[i] = !catchInfo.isReachable();
+ tryInfo = tryInfo.mergedWith(catchInfo.unconditionalInits());
+ }
+ }
+ if (subRoutineStartLabel == null) {
+ mergedInitStateIndex =
+ currentScope.methodScope().recordInitializationStates(tryInfo);
+ return tryInfo;
+ }
+
+
+ // we also need to check potential multiple assignments of final variables inside the finally block
+ // need to include potential inits from returns inside the try/catch parts - 1GK2AOF
+ finallyContext.complainOnRedundantFinalAssignments(
+ tryInfo.isReachable()
+ ? (tryInfo.addPotentialInitializationsFrom(insideSubContext.initsOnReturn))
+ : insideSubContext.initsOnReturn,
+ currentScope);
+ if (subInfo == FlowInfo.DEAD_END) {
+ mergedInitStateIndex =
+ currentScope.methodScope().recordInitializationStates(subInfo);
+ return subInfo;
+ } else {
+ FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
+ mergedInitStateIndex =
+ currentScope.methodScope().recordInitializationStates(mergedInfo);
+ return mergedInfo;
+ }
+ }
+
+ public boolean cannotReturn() {
+
+ return subRoutineCannotReturn;
+ }
+
+ /**
+ * Try statement code generation
+ *
+ */
+// public void generateCode(BlockScope currentScope, CodeStream codeStream) {
+//
+// if ((bits & IsReachableMASK) == 0) {
+// return;
+// }
+// if (tryBlock.isEmptyBlock()) {
+// if (subRoutineStartLabel != null) {
+// // since not passing the finallyScope, the block generation will exitUserScope(finallyScope)
+// finallyBlock.generateCode(scope, codeStream);
+// }
+// // May loose some local variable initializations : affecting the local variable attributes
+// if (mergedInitStateIndex != -1) {
+// codeStream.removeNotDefinitelyAssignedVariables(
+// currentScope,
+// mergedInitStateIndex);
+// }
+// // no local bytecode produced so no need for position remembering
+// return;
+// }
+// int pc = codeStream.position;
+// Label endLabel = new Label(codeStream);
+// boolean requiresNaturalJsr = false;
+//
+// // preparing exception labels
+// int maxCatches;
+// ExceptionLabel[] exceptionLabels =
+// new ExceptionLabel[maxCatches =
+// catchArguments == null ? 0 : catchArguments.length];
+// for (int i = 0; i < maxCatches; i++) {
+// boolean preserveCurrentHandler =
+// (preserveExceptionHandler[i
+// / ExceptionHandlingFlowContext.BitCacheSize]
+// & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
+// != 0;
+// if (preserveCurrentHandler) {
+// exceptionLabels[i] =
+// new ExceptionLabel(
+// codeStream,
+// (ReferenceBinding) catchArguments[i].binding.type);
+// }
+// }
+// ExceptionLabel anyExceptionLabel = null;
+// if (subRoutineStartLabel != null) {
+// subRoutineStartLabel.codeStream = codeStream;
+// anyExceptionLabel = new ExceptionLabel(codeStream, null);
+// }
+// // generate the try block
+// tryBlock.generateCode(scope, codeStream);
+// boolean tryBlockHasSomeCode = codeStream.position != pc;
+// // flag telling if some bytecodes were issued inside the try block
+//
+// // natural exit: only if necessary
+// boolean nonReturningSubRoutine =
+// (subRoutineStartLabel != null) && subRoutineCannotReturn;
+// if ((!tryBlockExit) && tryBlockHasSomeCode) {
+// int position = codeStream.position;
+// if (nonReturningSubRoutine) {
+// codeStream.goto_(subRoutineStartLabel);
+// } else {
+// requiresNaturalJsr = true;
+// codeStream.goto_(endLabel);
+// }
+// codeStream.updateLastRecordedEndPC(position);
+// //goto is tagged as part of the try block
+// }
+// // place end positions of user-defined exception labels
+// if (tryBlockHasSomeCode) {
+// for (int i = 0; i < maxCatches; i++) {
+// boolean preserveCurrentHandler =
+// (preserveExceptionHandler[i / ExceptionHandlingFlowContext.BitCacheSize]
+// & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
+// != 0;
+// if (preserveCurrentHandler) {
+// exceptionLabels[i].placeEnd();
+// }
+// }
+// /* generate sequence of handler, all starting by storing the TOS (exception
+// thrown) into their own catch variables, the one specified in the source
+// that must denote the handled exception.
+// */
+// if (catchArguments == null) {
+// if (anyExceptionLabel != null) {
+// anyExceptionLabel.placeEnd();
+// }
+// } else {
+// for (int i = 0; i < maxCatches; i++) {
+// boolean preserveCurrentHandler =
+// (preserveExceptionHandler[i / ExceptionHandlingFlowContext.BitCacheSize]
+// & (1 << (i % ExceptionHandlingFlowContext.BitCacheSize)))
+// != 0;
+// if (preserveCurrentHandler) {
+// // May loose some local variable initializations : affecting the local variable attributes
+// if (preTryInitStateIndex != -1) {
+// codeStream.removeNotDefinitelyAssignedVariables(
+// currentScope,
+// preTryInitStateIndex);
+// }
+// exceptionLabels[i].place();
+// codeStream.incrStackSize(1);
+// // optimizing the case where the exception variable is not actually used
+// LocalVariableBinding catchVar;
+// int varPC = codeStream.position;
+// if ((catchVar = catchArguments[i].binding).resolvedPosition != -1) {
+// codeStream.store(catchVar, false);
+// catchVar.recordInitializationStartPC(codeStream.position);
+// codeStream.addVisibleLocalVariable(catchVar);
+// } else {
+// codeStream.pop();
+// }
+// codeStream.recordPositionsFrom(varPC, catchArguments[i].sourceStart);
+// // Keep track of the pcs at diverging point for computing the local attribute
+// // since not passing the catchScope, the block generation will exitUserScope(catchScope)
+// catchBlocks[i].generateCode(scope, codeStream);
+// }
+// if (i == maxCatches - 1) {
+// if (anyExceptionLabel != null) {
+// anyExceptionLabel.placeEnd();
+// }
+// if (subRoutineStartLabel != null) {
+// if (!catchExits[i] && preserveCurrentHandler) {
+// requiresNaturalJsr = true;
+// codeStream.goto_(endLabel);
+// }
+// }
+// } else {
+// if (!catchExits[i] && preserveCurrentHandler) {
+// if (nonReturningSubRoutine) {
+// codeStream.goto_(subRoutineStartLabel);
+// } else {
+// requiresNaturalJsr = true;
+// codeStream.goto_(endLabel);
+// }
+// }
+// }
+// }
+// }
+// // addition of a special handler so as to ensure that any uncaught exception (or exception thrown
+// // inside catch blocks) will run the finally block
+// int finallySequenceStartPC = codeStream.position;
+// if (subRoutineStartLabel != null) {
+// // the additional handler is doing: jsr finallyBlock and rethrow TOS-exception
+// anyExceptionLabel.place();
+//
+// if (preTryInitStateIndex != -1) {
+// // reset initialization state, as for a normal catch block
+// codeStream.removeNotDefinitelyAssignedVariables(
+// currentScope,
+// preTryInitStateIndex);
+// }
+//
+// codeStream.incrStackSize(1);
+// if (nonReturningSubRoutine) {
+// codeStream.pop();
+// // "if subroutine cannot return, no need to jsr/jump to subroutine since it will be entered in sequence
+// } else {
+// codeStream.store(anyExceptionVariable, false);
+// codeStream.jsr(subRoutineStartLabel);
+// codeStream.load(anyExceptionVariable);
+// codeStream.athrow();
+// }
+// }
+// // end of catch sequence, place label that will correspond to the finally block beginning, or end of statement
+// endLabel.place();
+// if (subRoutineStartLabel != null) {
+// if (nonReturningSubRoutine) {
+// requiresNaturalJsr = false;
+// }
+// Label veryEndLabel = new Label(codeStream);
+// if (requiresNaturalJsr) {
+// codeStream.jsr(subRoutineStartLabel);
+// codeStream.goto_(veryEndLabel);
+// }
+// subRoutineStartLabel.place();
+// if (!nonReturningSubRoutine) {
+// codeStream.incrStackSize(1);
+// codeStream.store(returnAddressVariable, false);
+// }
+// codeStream.recordPositionsFrom(
+// finallySequenceStartPC,
+// finallyBlock.sourceStart);
+// // entire sequence for finally is associated to finally block
+// finallyBlock.generateCode(scope, codeStream);
+// if (!nonReturningSubRoutine) {
+// int position = codeStream.position;
+// codeStream.ret(returnAddressVariable.resolvedPosition);
+// codeStream.updateLastRecordedEndPC(position);
+// // the ret bytecode is part of the subroutine
+// }
+// if (requiresNaturalJsr) {
+// veryEndLabel.place();
+// }
+// }
+// } else {
+// // try block had no effect, only generate the body of the finally block if any
+// if (subRoutineStartLabel != null) {
+// finallyBlock.generateCode(scope, codeStream);
+// }
+// }
+// // May loose some local variable initializations : affecting the local variable attributes
+// if (mergedInitStateIndex != -1) {
+// codeStream.removeNotDefinitelyAssignedVariables(
+// currentScope,
+// mergedInitStateIndex);
+// codeStream.addDefinitelyAssignedVariables(currentScope, mergedInitStateIndex);
+// }
+// codeStream.recordPositionsFrom(pc, this.sourceStart);
+// }
+
+ public void resetStateForCodeGeneration() {
+ if (this.subRoutineStartLabel != null) {
+ this.subRoutineStartLabel.resetStateForCodeGeneration();
+ }
+ }
+ public StringBuffer printStatement(int indent, StringBuffer output) {
+ printIndent(indent, output).append("try \n"); //$NON-NLS-1$
+ tryBlock.printStatement(indent + 1, output); //$NON-NLS-1$
+
+ //catches
+ if (catchBlocks != null)
+ for (int i = 0; i < catchBlocks.length; i++) {
+ output.append('\n');
+ printIndent(indent, output).append("catch ("); //$NON-NLS-1$
+ catchArguments[i].print(0, output).append(") "); //$NON-NLS-1$
+ catchBlocks[i].printStatement(indent + 1, output);
+ }
+ //finally
+ if (finallyBlock != null) {
+ output.append('\n');
+ printIndent(indent, output).append("finally\n"); //$NON-NLS-1$
+ finallyBlock.printStatement(indent + 1, output);
+ }
+
+ return output;
+ }
+ public void resolve(BlockScope upperScope) {
+
+ // special scope for secret locals optimization.
+ this.scope = new BlockScope(upperScope);
+
+ BlockScope tryScope = new BlockScope(scope);
+ BlockScope finallyScope = null;
+
+ if (finallyBlock != null
+ && finallyBlock.statements != null) {
+
+ finallyScope = new BlockScope(scope, false); // don't add it yet to parent scope
+
+ // provision for returning and forcing the finally block to run
+ MethodScope methodScope = scope.methodScope();
+
+ // the type does not matter as long as it is not a base type
+ this.returnAddressVariable =
+ new LocalVariableBinding(SecretReturnName, upperScope.getJavaLangObject(), AccDefault, false);
+ finallyScope.addLocalVariable(returnAddressVariable);
+ this.returnAddressVariable.constant = NotAConstant; // not inlinable
+ this.subRoutineStartLabel = new Label();
+
+ this.anyExceptionVariable =
+ new LocalVariableBinding(SecretAnyHandlerName, scope.getJavaLangThrowable(), AccDefault, false);
+ finallyScope.addLocalVariable(this.anyExceptionVariable);
+ this.anyExceptionVariable.constant = NotAConstant; // not inlinable
+
+ if (!methodScope.isInsideInitializer()) {
+ MethodBinding methodBinding =
+ ((AbstractMethodDeclaration) methodScope.referenceContext).binding;
+ if (methodBinding != null) {
+ TypeBinding methodReturnType = methodBinding.returnType;
+ if (methodReturnType.id != T_void) {
+ this.secretReturnValue =
+ new LocalVariableBinding(
+ SecretLocalDeclarationName,
+ methodReturnType,
+ AccDefault,
+ false);
+ finallyScope.addLocalVariable(this.secretReturnValue);
+ this.secretReturnValue.constant = NotAConstant; // not inlinable
+ }
+ }
+ }
+ finallyBlock.resolveUsing(finallyScope);
+ // force the finally scope to have variable positions shifted after its try scope and catch ones
+ finallyScope.shiftScopes = new BlockScope[catchArguments == null ? 1 : catchArguments.length+1];
+ finallyScope.shiftScopes[0] = tryScope;
+ }
+ this.tryBlock.resolveUsing(tryScope);
+
+ // arguments type are checked against JavaLangThrowable in resolveForCatch(..)
+ if (this.catchBlocks != null) {
+ int length = this.catchArguments.length;
+ TypeBinding[] argumentTypes = new TypeBinding[length];
+ for (int i = 0; i < length; i++) {
+ BlockScope catchScope = new BlockScope(scope);
+ if (finallyScope != null){
+ finallyScope.shiftScopes[i+1] = catchScope;
+ }
+ // side effect on catchScope in resolveForCatch(..)
+ if ((argumentTypes[i] = catchArguments[i].resolveForCatch(catchScope)) == null)
+ return;
+ catchBlocks[i].resolveUsing(catchScope);
+ }
+
+ // Verify that the catch clause are ordered in the right way:
+ // more specialized first.
+ this.caughtExceptionTypes = new ReferenceBinding[length];
+ for (int i = 0; i < length; i++) {
+ caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
+ for (int j = 0; j < i; j++) {
+ if (caughtExceptionTypes[i].isCompatibleWith(argumentTypes[j])) {
+ scope.problemReporter().wrongSequenceOfExceptionTypesError(this, i, j);
+ // cannot return - since may still proceed if unreachable code is ignored (21203)
+ }
+ }
+ }
+ } else {
+ caughtExceptionTypes = new ReferenceBinding[0];
+ }
+
+ if (finallyScope != null){
+ // add finallyScope as last subscope, so it can be shifted behind try/catch subscopes.
+ // the shifting is necessary to achieve no overlay in between the finally scope and its
+ // sibling in term of local variable positions.
+ this.scope.addSubscope(finallyScope);
+ }
+ }
+
+ public String toString(int tab) {
+ String s = tabString(tab);
+ //try
+ s = s + "try "; //$NON-NLS-1$
+ if (tryBlock == Block.None)
+ s = s + "{}"; //$NON-NLS-1$
+ else
+ s = s + "\n" + tryBlock.toString(tab + 1); //$NON-NLS-1$
+
+ //catches
+ if (catchBlocks != null)
+ for (int i = 0; i < catchBlocks.length; i++)
+ s = s + "\n" + tabString(tab) + "catch (" //$NON-NLS-2$ //$NON-NLS-1$
+ +catchArguments[i].toString(0) + ") " //$NON-NLS-1$
+ +catchBlocks[i].toString(tab + 1);
+ //finally
+ if (finallyBlock != null) {
+ if (finallyBlock == Block.None)
+ s = s + "\n" + tabString(tab) + "finally {}"; //$NON-NLS-2$ //$NON-NLS-1$
+ else
+ s = s + "\n" + tabString(tab) + "finally\n" + //$NON-NLS-2$ //$NON-NLS-1$
+ finallyBlock.toString(tab + 1);
+ }
+
+ return s;
+ }
+
+ public void traverse(
+ ASTVisitor visitor,
+ BlockScope blockScope) {
+
+ if (visitor.visit(this, blockScope)) {
+ tryBlock.traverse(visitor, scope);
+ if (catchArguments != null) {
+ for (int i = 0, max = catchBlocks.length; i < max; i++) {
+ catchArguments[i].traverse(visitor, scope);
+ catchBlocks[i].traverse(visitor, scope);
+ }
+ }
+ if (finallyBlock != null)
+ finallyBlock.traverse(visitor, scope);
+ }
+ visitor.endVisit(this, blockScope);
+ }
+}
git://git.phpeclipse.com / phpeclipse.git / blobdiff