/*******************************************************************************
 * Copyright (c) 2001, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jem.internal.proxy.initParser;
/*


 */


public class Statement extends Expression {
	public boolean isStringObject = false;
	public boolean isCast = false;
	protected boolean messageOrFieldStarted;
	
/**
 * Statement constructor comment.
 */
public Statement(ClassLoader aClassLoader) {
	super();
	fClassLoader = aClassLoader;
}

public boolean isComplete(){
	return currentExpression != null && currentExpression.isComplete();
}

/** Defer this to the expression
 */
public Object evaluate() throws Exception {
	if ( currentExpression != null ) {
		return currentExpression.evaluate();
	} else {
		throw new RuntimeException(ProxyInitParserMessages.getString(ProxyInitParserMessages.STATEMENT_UNEXPECTED_EXECUTION));	// This is not an evaluation error, it shouldn't of occured, so it is a parser error.
	}
}
/**
 */
public Class getTypeClass() throws Exception {
	return currentExpression.getTypeClass();
	//throw new RuntimeException(ProxyBaseVMNLS.RESBUNDLE.getString(ProxyBaseVMNLS.STATEMENT_UNEXPECTED_EVALUATION));
}

protected String getTypeClassName() {
	return currentExpression.getTypeClassName();
}
/** There are several types of token that can begin a statement.
 *  new , ' '						-	Create a constructor
 *	1-10, true, false, etc...		-	Create a literal
 *  Foo,  '.'						-	Create a Type
 */
public Expression push(char[] token , char delimiter){
	
	// If messageOrFieldStart is true then our expression is complete and either a message or field is being created
	// See which it is and create the correct expression
	if (messageOrFieldStarted){
		messageOrFieldStarted = false;
		if ( delimiter == DelimiterOpenParen){
			Message message = new Message(currentExpression,token,fClassLoader);
			currentExpression = message;
			return message;
		} else { 
			Field field = new Field(currentExpression,token,fClassLoader);
			currentExpression = field;
			return field;
		}
	}	
	
	// Look for "new " for a constructor"
	if ( delimiter == DelimiterSpace && compare( token , ConstantNew ) ) {
		// If we thought we were a possible cast and we now aren't then we must be a block expression
		if ( isCast ) {
			currentExpression = new Block(new Constructor(fClassLoader));
		} else {
			currentExpression = new Constructor(fClassLoader);
		}
		isCast = false;	// Can't be a cast now		
		return currentExpression;
	}
	
	// Look for "null" 
	if ( compare( token , ConstantNull ) ) {
		currentExpression = new NullLiteral();
		isCast = false;	// Can't be a cast now		
		// Null cannot process anything so we return the statement
		return this;
	}

	// Look for a number
	if ( isNumber( token ) || delimiter == OperMinus ) {
		currentExpression = new NumberLiteral();
		currentExpression = currentExpression.push(token,delimiter);
		isCast = false;	// Can't be a cast now		
		return currentExpression;
	}

	if ( compare( token , ConstantTrue ) ) {
		currentExpression  = new BooleanLiteral(true);
		// true cannot process anything so we return the statement
		isCast = false;	// Can't be a cast now		
		return currentExpression;
//		return this;
	}

	if ( compare( token , ConstantFalse ) ) {
		// false cannot process anything so we return the statement
		currentExpression = new BooleanLiteral(false);
		isCast = false;	// Can't be a cast now		
		return this;
	}
	
	if ( delimiter == DelimiterQuote ) {
		currentExpression = new StringLiteral();
		isCast = false;	// Can't be a cast now		
		return currentExpression;		
	}
	
	if ( delimiter == DelimiterSingleQuote ) {
		currentExpression = new CharLiteral();
		isCast = false;	// Can't be a cast now		
		return currentExpression;		
	}	
	
	if (delimiter == DelimiterPeriod && token.length == 0 && currentExpression != null){
		if (currentExpression instanceof StringLiteral){
			//String s = "\"" + (String)(currentExpression.evaluate()) + "\"" ;
			//return new Constructor(s);
			isStringObject = true;
			return this;
		}
	}
	
	if (isStringObject && (token.length > 0) && (delimiter == DelimiterOpenParen)){
		return new Message(currentExpression, token,fClassLoader);
	}
	
	//handle type casting
	if ((token.length == 0) && (delimiter == DelimiterOpenParen)){
		// If we are a already a cast then we must be a block.
		if ( isCast ) {
			currentExpression = new Block(fClassLoader);
		} else {
			isCast = true;	// Possibly a cast
		}
		return this;
	}	
	if (isCast && (delimiter == DelimiterCloseParen || token.length != 0)){
		Static aStatic = new Static(fClassLoader);
		Cast aCast = new Cast(aStatic,fClassLoader);
		currentExpression = aCast.push(token,delimiter);
		return currentExpression;
	}
	
	if ( token.length != 0 ) {
		currentExpression = new Static(fClassLoader).push(token,delimiter);
		return currentExpression;
	}
	
	// If we get a { then we are part of an array argument
	if (delimiter == DelimiterOpenElipse){
		currentExpression = new ArrayArguments();
		return currentExpression;
	}
	
	// If our expression is closed and we receive a . we are either a message or a field.  We won't know this until
	// the next token we receive, which will be either be delimited by a ( in which case it is a message, else it is a field
	if (currentExpression != null && currentExpression.isComplete() && delimiter == DelimiterPeriod){
		messageOrFieldStarted = true;
	}
		
	return this;
}

public String toString(){
	StringBuffer buffer = new StringBuffer();
	buffer.append("Statement{"); //$NON-NLS-1$
	if ( currentExpression != null ) {
		buffer.append(currentExpression.toString());
	}
	buffer.append('}');
	return buffer.toString();
}
/**
 * Is this statement a primitive.
 */
public boolean isPrimitive() throws Exception {
	if ( currentExpression != null ) {
		return currentExpression.isPrimitive();
	} else {
		throw new RuntimeException(ProxyInitParserMessages.getString(ProxyInitParserMessages.STATEMENT_UNEXPECTED_EXECUTION));
	}
}
}