X-Git-Url: http://secure.phpeclipse.com

diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ReturnStatement.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ReturnStatement.java
new file mode 100644
index 0000000..8da806d
--- /dev/null
+++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ReturnStatement.java
@@ -0,0 +1,249 @@
+/*******************************************************************************
+ * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * All rights reserved. This program and the accompanying materials 
+ * are made available under the terms of the Common Public License v0.5 
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v05.html
+ * 
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ ******************************************************************************/
+package net.sourceforge.phpdt.internal.compiler.ast;
+
+import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
+import net.sourceforge.phpdt.internal.compiler.codegen.*;
+import net.sourceforge.phpdt.internal.compiler.flow.*;
+import net.sourceforge.phpdt.internal.compiler.lookup.*;
+
+public class ReturnStatement extends Statement {
+	public Expression expression;
+
+	public TypeBinding expressionType;
+	public boolean isSynchronized;
+	public AstNode[] subroutines;
+	public LocalVariableBinding saveValueVariable;
+
+public ReturnStatement(Expression expr, int s, int e ) {
+	sourceStart = s;
+	sourceEnd = e;
+	expression = expr ;
+}
+public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	// here requires to generate a sequence of finally blocks invocations depending corresponding
+	// to each of the traversed try statements, so that execution will terminate properly.
+
+	// lookup the label, this should answer the returnContext
+
+	if (expression != null) {
+		flowInfo = expression.analyseCode(currentScope, flowContext, flowInfo);
+	}
+	// compute the return sequence (running the finally blocks)
+	FlowContext traversedContext = flowContext;
+	int subIndex = 0, maxSub = 5;
+	boolean saveValueNeeded = false;
+	boolean hasValueToSave = expression != null && expression.constant == NotAConstant;
+	while (true) {
+		AstNode sub;
+		if ((sub = traversedContext.subRoutine()) != null) {
+			if (this.subroutines == null){
+				this.subroutines = new AstNode[maxSub];
+			}
+			if (subIndex == maxSub) {
+				System.arraycopy(this.subroutines, 0, (this.subroutines = new AstNode[maxSub *= 2]), 0, subIndex); // grow
+			}
+			this.subroutines[subIndex++] = sub;
+			if (sub.cannotReturn()) {
+				saveValueNeeded = false;
+				break;
+			}
+		}
+		AstNode node;
+
+		if ((node = traversedContext.associatedNode) instanceof SynchronizedStatement) {
+			isSynchronized = true;
+
+		} else if (node instanceof TryStatement && hasValueToSave) {
+				if (this.saveValueVariable == null){ // closest subroutine secret variable is used
+					prepareSaveValueLocation((TryStatement)node);
+				}
+				saveValueNeeded = true;
+
+		} else if (traversedContext instanceof InitializationFlowContext) {
+				currentScope.problemReporter().cannotReturnInInitializer(this);
+				return FlowInfo.DeadEnd;
+		}
+
+		// remember the initialization at this
+		// point for dealing with blank final variables.
+		traversedContext.recordReturnFrom(flowInfo.unconditionalInits());
+
+		FlowContext parentContext;
+		if ((parentContext = traversedContext.parent) == null) { // top-context
+			break;
+		} else {
+			traversedContext = parentContext;
+		}
+	}
+	// resize subroutines
+	if ((subroutines != null) && (subIndex != maxSub)) {
+		System.arraycopy(subroutines, 0, (subroutines = new AstNode[subIndex]), 0, subIndex);
+	}
+
+	// secret local variable for return value (note that this can only occur in a real method)
+	if (saveValueNeeded) {
+		if (this.saveValueVariable != null) {
+			this.saveValueVariable.used = true;
+		}
+	} else {
+		this.saveValueVariable = null;
+		if ((!isSynchronized) && (expressionType == BooleanBinding)) {
+			this.expression.bits |= ValueForReturnMASK;
+		}
+	}
+	return FlowInfo.DeadEnd;
+}
+ 
+/**
+ * Retrun statement code generation
+ *
+ *   generate the finallyInvocationSequence.
+ *
+ * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
+ * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
+ */
+public void generateCode(BlockScope currentScope, CodeStream codeStream) {
+	if ((bits & IsReachableMASK) == 0) {
+		return;
+	}
+	int pc = codeStream.position;
+	// generate the expression
+	if ((expression != null) && (expression.constant == NotAConstant)) {
+		expression.generateCode(currentScope, codeStream, needValue()); // no value needed if non-returning subroutine
+		generateStoreSaveValueIfNecessary(currentScope, codeStream);
+	}
+	
+	// generation of code responsible for invoking the finally blocks in sequence
+	if (subroutines != null) {
+		for (int i = 0, max = subroutines.length; i < max; i++) {
+			AstNode sub;
+			if ((sub = subroutines[i]) instanceof SynchronizedStatement) {
+				codeStream.load(((SynchronizedStatement) sub).synchroVariable);
+				codeStream.monitorexit();
+			} else {
+				TryStatement trySub = (TryStatement) sub;
+				if (trySub.subRoutineCannotReturn) {
+					codeStream.goto_(trySub.subRoutineStartLabel);
+					codeStream.recordPositionsFrom(pc, this.sourceStart);
+					return;
+				} else {
+					codeStream.jsr(trySub.subRoutineStartLabel);
+				}
+			}
+		}
+	}
+	if (saveValueVariable != null) codeStream.load(saveValueVariable);
+	
+	if ((expression != null) && (expression.constant != NotAConstant)) {
+		codeStream.generateConstant(expression.constant, expression.implicitConversion);
+		generateStoreSaveValueIfNecessary(currentScope, codeStream);		
+	}
+	// output the suitable return bytecode or wrap the value inside a descriptor for doits
+	this.generateReturnBytecode(currentScope, codeStream);
+	
+	codeStream.recordPositionsFrom(pc, this.sourceStart);
+}
+/**
+ * Dump the suitable return bytecode for a return statement
+ *
+ */
+public void generateReturnBytecode(BlockScope currentScope, CodeStream codeStream) {
+
+	if (expression == null) {
+		codeStream.return_();
+	} else {
+		switch (expression.implicitConversion >> 4) {
+			case T_boolean :
+			case T_int :
+				codeStream.ireturn();
+				break;
+			case T_float :
+				codeStream.freturn();
+				break;
+			case T_long :
+				codeStream.lreturn();
+				break;
+			case T_double :
+				codeStream.dreturn();
+				break;
+			default :
+				codeStream.areturn();
+		}
+	}
+}
+public void generateStoreSaveValueIfNecessary(BlockScope currentScope, CodeStream codeStream){
+
+	if (saveValueVariable != null) codeStream.store(saveValueVariable, false);
+}
+public boolean needValue(){
+	return (subroutines == null) || (saveValueVariable != null) || isSynchronized;
+}
+public void prepareSaveValueLocation(TryStatement targetTryStatement){
+		
+	this.saveValueVariable = targetTryStatement.secretReturnValue;
+}
+public void resolve(BlockScope scope) {
+	MethodScope methodScope = scope.methodScope();
+	MethodBinding methodBinding;
+	TypeBinding methodType =
+		(methodScope.referenceContext instanceof AbstractMethodDeclaration)
+			? ((methodBinding = ((AbstractMethodDeclaration) methodScope.referenceContext).binding) == null 
+				? null 
+				: methodBinding.returnType)
+			: VoidBinding;
+	if (methodType == VoidBinding) {
+		// the expression should be null
+		if (expression == null)
+			return;
+		if ((expressionType = expression.resolveType(scope)) != null)
+			scope.problemReporter().attemptToReturnNonVoidExpression(this, expressionType);
+		return;
+	}
+	if (expression == null) {
+		if (methodType != null) scope.problemReporter().shouldReturn(methodType, this);
+		return;
+	}
+	if ((expressionType = expression.resolveType(scope)) == null)
+		return;
+
+	if (methodType != null && expression.isConstantValueOfTypeAssignableToType(expressionType, methodType)) {
+		// dealing with constant
+		expression.implicitWidening(methodType, expressionType);
+		return;
+	}
+	if (expressionType == VoidBinding) {
+		scope.problemReporter().attemptToReturnVoidValue(this);
+		return;
+	}
+	if (methodType != null && scope.areTypesCompatible(expressionType, methodType)) {
+		expression.implicitWidening(methodType, expressionType);
+		return;
+	}
+	if (methodType != null){
+		scope.problemReporter().typeMismatchErrorActualTypeExpectedType(expression, expressionType, methodType);
+	}
+}
+public String toString(int tab){
+
+	String s = tabString(tab) ;
+	s = s + "return "; //$NON-NLS-1$
+	if (expression != null )
+		s = s + expression.toStringExpression() ;
+	return s;
+}
+public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
+	if (visitor.visit(this, scope)) {
+		if (expression != null)
+			expression.traverse(visitor, scope);
+	}
+	visitor.endVisit(this, scope);
+}
+}