compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java - gerrit/e4/org.eclipse.jdt.core - Git at Google

 package org.eclipse.jdt.internal.compiler.ast;

 /*
  * (c) Copyright IBM Corp. 2000, 2001.
  * All Rights Reserved.
  */
 import org.eclipse.jdt.internal.compiler.IAbstractSyntaxTreeVisitor;
 import org.eclipse.jdt.internal.compiler.impl.*;
 import org.eclipse.jdt.internal.compiler.codegen.*;
 import org.eclipse.jdt.internal.compiler.flow.*;
 import org.eclipse.jdt.internal.compiler.lookup.*;
 import org.eclipse.jdt.internal.compiler.problem.*;

 public class TryStatement extends Statement {
 	public Block tryBlock;
 	public Block[] catchBlocks;
 	public Argument[] catchArguments;
 	public Block finallyBlock;

 	BlockScope scope;

 	public boolean subRoutineCannotReturn = true; // should rename into subRoutineComplete to be set to false by default

 	ReferenceBinding[] caughtExceptionTypes;
 	boolean tryBlockExit;
 	boolean[] catchExits;
 	public int[] preserveExceptionHandler;

 	Label subRoutineStartLabel;
 	LocalVariableBinding anyExceptionVariable, returnAddressVariable;

 	final static char[] SecretReturnName = " returnAddress"/*nonNLS*/.toCharArray() ;
 	final static char[] SecretAnyHandlerName = " anyExceptionHandler"/*nonNLS*/.toCharArray();

 	// for local variables table attributes
 	int preTryInitStateIndex = -1;
 	int mergedInitStateIndex = -1;
 /**
  * TryStatement constructor comment.
  */
 public TryStatement() {
 	super();
 }
 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.used = true;
 	}
 	if (returnAddressVariable != null) {
 		returnAddressVariable.used = true;
 	}
 	FlowContext insideSubContext;
 	FinallyFlowContext finallyContext;
 	UnconditionalFlowInfo subInfo;
 	if (subRoutineStartLabel == null) {
 		insideSubContext = flowContext;
 		finallyContext = null;
 		subInfo = null;
 	} else {
 		insideSubContext = new InsideSubRoutineFlowContext(flowContext, this);
 		subInfo = finallyBlock.analyseCode(
 			currentScope,
 			finallyContext = new FinallyFlowContext(flowContext, finallyBlock),
 			flowInfo.copy()).
 				unconditionalInits();
 		if (!((subInfo == FlowInfo.DeadEnd) || subInfo.isFakeReachable())) {
 			subRoutineCannotReturn = false;
 		}
 	}

 	// process the try block in a context handling the local exceptions.
 	ExceptionHandlingFlowContext handlingContext =
 		new ExceptionHandlingFlowContext(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 == FlowInfo.DeadEnd) || tryInfo.isFakeReachable();
 	}

 	// 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());
 			//*/
 			// SMART ANALYSIS (see 1FBPLCY)
 			//FlowInfo catchInfo = handlingContext.initsOnException(caughtExceptionTypes[i]);

 			// 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]."
 			*/
 			if (tryBlock.statements == null) {
 				catchInfo.markAsFakeReachable(true);
 			}
 			catchInfo = catchBlocks[i].analyseCode(currentScope, insideSubContext, catchInfo);
 			catchExits[i] = ((catchInfo == FlowInfo.DeadEnd) || catchInfo.isFakeReachable());
 			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
 	finallyContext.complainOnRedundantFinalAssignments(tryInfo, currentScope);
 	if (subInfo == FlowInfo.DeadEnd) {
 		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]);
 					// 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); // 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);
 }
 public void resolve(BlockScope upperScope) {

 	// special scope for secret locals optimization.
 	scope = new BlockScope(upperScope);
 	if (finallyBlock != null && finallyBlock.statements != null) { // provision for returning and forcing the finally block to run
 		returnAddressVariable = new LocalVariableBinding(SecretReturnName, upperScope.getJavaLangObject(), 0); // the type does not matter as long as its not a normal base type
 		scope.addLocalVariable(returnAddressVariable);
 		returnAddressVariable.constant = NotAConstant; // not inlinable
 		subRoutineStartLabel = new Label();

 		BlockScope finallyScope = new BlockScope(scope);
 		anyExceptionVariable = new LocalVariableBinding(SecretAnyHandlerName, scope.getJavaLangThrowable(), 0);
 		finallyScope.addLocalVariable(anyExceptionVariable);
 		anyExceptionVariable.constant = NotAConstant; // not inlinable
 		finallyBlock.resolveUsing(finallyScope);
 	}
 	tryBlock.resolve(scope);

 	// arguments type are checked against JavaLangThrowable in resolveForCatch(..)
 	if (catchBlocks != null) {
 		int length = catchArguments.length;
 		TypeBinding[] argumentTypes = new TypeBinding[length];
 		for (int i = 0; i < length; i++) {
 			BlockScope catchScope = new BlockScope(scope);
 			// 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.
 		caughtExceptionTypes = new ReferenceBinding[length];
 		for (int i = 0; i < length; i++) {
 			caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
 			for (int j = 0; j < i; j++) {
 				if (scope.areTypesCompatible(caughtExceptionTypes[i], argumentTypes[j])) {
 					scope.problemReporter().wrongSequenceOfExceptionTypesError(this, i, j);
 					return;
 				}
 			}
 		}
 	} else {
 		caughtExceptionTypes = new ReferenceBinding[0];
 	}
 }
 public String toString(int tab){
 	/* slow code */

 	String s = tabString(tab) ;
 	//try
 	s = s + "try "/*nonNLS*/ ;
 	if (tryBlock == Block.None)
 		s =s + "{}"/*nonNLS*/ ;
 	else
 		s = s + "\n"/*nonNLS*/ + tryBlock.toString(tab+1) ;

 	//catches
 	if (catchBlocks != null)
 		for (int i = 0; i < catchBlocks.length ; i++)
 			s = s 	+ "\n"/*nonNLS*/ + tabString(tab) + "catch ("/*nonNLS*/
 					+ catchArguments[i].toString(0) + ") "/*nonNLS*/
 					+ catchBlocks[i].toString(tab+1) ;
 	//finally
 	if (finallyBlock != null)
 	{	if (finallyBlock == Block.None)
 			s = s + "\n"/*nonNLS*/ + tabString(tab)+ "finally {}"/*nonNLS*/ ;
 		else
 			s = s + "\n"/*nonNLS*/ + tabString(tab)+ "finally\n"/*nonNLS*/ +
 				finallyBlock.toString(tab+1) ;}

 	return s ;}
 public void traverse(IAbstractSyntaxTreeVisitor 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);
 }
 }
	package org.eclipse.jdt.internal.compiler.ast;

	/*
	* (c) Copyright IBM Corp. 2000, 2001.
	* All Rights Reserved.
	*/
	import org.eclipse.jdt.internal.compiler.IAbstractSyntaxTreeVisitor;
	import org.eclipse.jdt.internal.compiler.impl.*;
	import org.eclipse.jdt.internal.compiler.codegen.*;
	import org.eclipse.jdt.internal.compiler.flow.*;
	import org.eclipse.jdt.internal.compiler.lookup.*;
	import org.eclipse.jdt.internal.compiler.problem.*;

	public class TryStatement extends Statement {
	public Block tryBlock;
	public Block[] catchBlocks;
	public Argument[] catchArguments;
	public Block finallyBlock;

	BlockScope scope;

	public boolean subRoutineCannotReturn = true; // should rename into subRoutineComplete to be set to false by default

	ReferenceBinding[] caughtExceptionTypes;
	boolean tryBlockExit;
	boolean[] catchExits;
	public int[] preserveExceptionHandler;

	Label subRoutineStartLabel;
	LocalVariableBinding anyExceptionVariable, returnAddressVariable;

	final static char[] SecretReturnName = " returnAddress"/nonNLS/.toCharArray() ;
	final static char[] SecretAnyHandlerName = " anyExceptionHandler"/nonNLS/.toCharArray();

	// for local variables table attributes
	int preTryInitStateIndex = -1;
	int mergedInitStateIndex = -1;
	/**
	* TryStatement constructor comment.
	*/
	public TryStatement() {
	super();
	}
	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.used = true;
	}
	if (returnAddressVariable != null) {
	returnAddressVariable.used = true;
	}
	FlowContext insideSubContext;
	FinallyFlowContext finallyContext;
	UnconditionalFlowInfo subInfo;
	if (subRoutineStartLabel == null) {
	insideSubContext = flowContext;
	finallyContext = null;
	subInfo = null;
	} else {
	insideSubContext = new InsideSubRoutineFlowContext(flowContext, this);
	subInfo = finallyBlock.analyseCode(
	currentScope,
	finallyContext = new FinallyFlowContext(flowContext, finallyBlock),
	flowInfo.copy()).
	unconditionalInits();
	if (!((subInfo == FlowInfo.DeadEnd) \|\| subInfo.isFakeReachable())) {
	subRoutineCannotReturn = false;
	}
	}

	// process the try block in a context handling the local exceptions.
	ExceptionHandlingFlowContext handlingContext =
	new ExceptionHandlingFlowContext(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 == FlowInfo.DeadEnd) \|\| tryInfo.isFakeReachable();
	}

	// 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());
	//*/
	// SMART ANALYSIS (see 1FBPLCY)
	//FlowInfo catchInfo = handlingContext.initsOnException(caughtExceptionTypes[i]);

	// 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]."
	*/
	if (tryBlock.statements == null) {
	catchInfo.markAsFakeReachable(true);
	}
	catchInfo = catchBlocks[i].analyseCode(currentScope, insideSubContext, catchInfo);
	catchExits[i] = ((catchInfo == FlowInfo.DeadEnd) \|\| catchInfo.isFakeReachable());
	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
	finallyContext.complainOnRedundantFinalAssignments(tryInfo, currentScope);
	if (subInfo == FlowInfo.DeadEnd) {
	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]);
	// 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); // 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);
	}
	public void resolve(BlockScope upperScope) {

	// special scope for secret locals optimization.
	scope = new BlockScope(upperScope);
	if (finallyBlock != null && finallyBlock.statements != null) { // provision for returning and forcing the finally block to run
	returnAddressVariable = new LocalVariableBinding(SecretReturnName, upperScope.getJavaLangObject(), 0); // the type does not matter as long as its not a normal base type
	scope.addLocalVariable(returnAddressVariable);
	returnAddressVariable.constant = NotAConstant; // not inlinable
	subRoutineStartLabel = new Label();

	BlockScope finallyScope = new BlockScope(scope);
	anyExceptionVariable = new LocalVariableBinding(SecretAnyHandlerName, scope.getJavaLangThrowable(), 0);
	finallyScope.addLocalVariable(anyExceptionVariable);
	anyExceptionVariable.constant = NotAConstant; // not inlinable
	finallyBlock.resolveUsing(finallyScope);
	}
	tryBlock.resolve(scope);

	// arguments type are checked against JavaLangThrowable in resolveForCatch(..)
	if (catchBlocks != null) {
	int length = catchArguments.length;
	TypeBinding[] argumentTypes = new TypeBinding[length];
	for (int i = 0; i < length; i++) {
	BlockScope catchScope = new BlockScope(scope);
	// 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.
	caughtExceptionTypes = new ReferenceBinding[length];
	for (int i = 0; i < length; i++) {
	caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
	for (int j = 0; j < i; j++) {
	if (scope.areTypesCompatible(caughtExceptionTypes[i], argumentTypes[j])) {
	scope.problemReporter().wrongSequenceOfExceptionTypesError(this, i, j);
	return;
	}
	}
	}
	} else {
	caughtExceptionTypes = new ReferenceBinding[0];
	}
	}
	public String toString(int tab){
	/* slow code */

	String s = tabString(tab) ;
	//try
	s = s + "try "/nonNLS/ ;
	if (tryBlock == Block.None)
	s =s + "{}"/nonNLS/ ;
	else
	s = s + "\n"/nonNLS/ + tryBlock.toString(tab+1) ;

	//catches
	if (catchBlocks != null)
	for (int i = 0; i < catchBlocks.length ; i++)
	s = s + "\n"/nonNLS/ + tabString(tab) + "catch ("/nonNLS/
	+ catchArguments[i].toString(0) + ") "/nonNLS/
	+ catchBlocks[i].toString(tab+1) ;
	//finally
	if (finallyBlock != null)
	{ if (finallyBlock == Block.None)
	s = s + "\n"/nonNLS/ + tabString(tab)+ "finally {}"/nonNLS/ ;
	else
	s = s + "\n"/nonNLS/ + tabString(tab)+ "finally\n"/nonNLS/ +
	finallyBlock.toString(tab+1) ;}

	return s ;}
	public void traverse(IAbstractSyntaxTreeVisitor 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);
	}
	}