/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
//
/**
* @author Neeraj Joshi <jneeraj@us.ibm.com>
*
*/
package org.apache.imperius.spl.parser.factory;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;
import org.apache.imperius.spl.core.Expression;
import org.apache.imperius.spl.core.TypeConstants;
import org.apache.imperius.spl.parser.compiler.SPLTreeParserTokenTypes;
import org.apache.imperius.spl.parser.compiler.symboltable.SPLSymbolTable;
import org.apache.imperius.spl.parser.exceptions.SPLException;
import org.apache.imperius.spl.parser.expression.primary.BasicCollectionExpression;
import org.apache.imperius.spl.parser.expression.primary.CollectOperation;
import org.apache.imperius.spl.parser.expression.primary.PostCollectExpression;
import org.apache.imperius.spl.parser.expression.primary.PrimaryExpression;
import org.apache.imperius.spl.parser.expression.primary.SelfExpression;
import org.apache.imperius.spl.parser.expressions.impl.Addition;
import org.apache.imperius.spl.parser.expressions.impl.AssignmentExpression;
import org.apache.imperius.spl.parser.expressions.impl.BooleanConstant;
import org.apache.imperius.spl.parser.expressions.impl.CharConstant;
import org.apache.imperius.spl.parser.expressions.impl.DateTime;
import org.apache.imperius.spl.parser.expressions.impl.DateTimeConstant;
import org.apache.imperius.spl.parser.expressions.impl.Division;
import org.apache.imperius.spl.parser.expressions.impl.DoubleConstant;
import org.apache.imperius.spl.parser.expressions.impl.Equal;
import org.apache.imperius.spl.parser.expressions.impl.FloatConstant;
import org.apache.imperius.spl.parser.expressions.impl.Greater;
import org.apache.imperius.spl.parser.expressions.impl.GreaterOrEqual;
import org.apache.imperius.spl.parser.expressions.impl.IntegerConstant;
import org.apache.imperius.spl.parser.expressions.impl.Less;
import org.apache.imperius.spl.parser.expressions.impl.LessOrEqual;
import org.apache.imperius.spl.parser.expressions.impl.LogicalAnd;
import org.apache.imperius.spl.parser.expressions.impl.LogicalNot;
import org.apache.imperius.spl.parser.expressions.impl.LogicalOr;
import org.apache.imperius.spl.parser.expressions.impl.LogicalXor;
import org.apache.imperius.spl.parser.expressions.impl.LongConstant;
import org.apache.imperius.spl.parser.expressions.impl.NotEqual;
import org.apache.imperius.spl.parser.expressions.impl.Product;
import org.apache.imperius.spl.parser.expressions.impl.ShortConstant;
import org.apache.imperius.spl.parser.expressions.impl.StringConstant;
import org.apache.imperius.spl.parser.expressions.impl.Subtraction;
import org.apache.imperius.spl.parser.expressions.impl.UnaryMinusExpression;
import org.apache.imperius.spl.parser.expressions.impl.UnaryPlusExpression;
import org.apache.imperius.util.Messages;
import org.apache.imperius.util.SPLLogger;
//PB: have added a utility to create java Calendar from the CIMDateTime string
//PB: have added a utility to check if a string is a CIMDateTime string
//that is parsed
public class ExpressionFactory
{
private static String GMT = "GMT";
private static int UTC_MULTIPLIER = 60000;
private static Logger logger = SPLLogger.getSPLLogger().getLogger();
private static final String sourceClass="ExpressionFactory";
public static Expression createExpression(Expression e1, Expression e2,
int type, SPLSymbolTable sTab) throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createExpression");
// System.out.println("creating expression " + e1.getClass() + " "+
// e2.getClass() + " " + type);
Expression returnExpr = null;
List exprList = new ArrayList(2); // DAW
exprList.add(e1);
exprList.add(e2);
boolean validateExpr = true;
if (sTab.getSymbolTableType() == SPLSymbolTable.COLLECT)
{
// System.out.println("sTab.getSymbolTableType() ==
// SPLSymbolTable.COLLECT");
validateExpr = false;
}
switch (type)
{
case SPLTreeParserTokenTypes.ASSIGN:
// System.out.println("Expression Factory::Creating assignment
// expression");
returnExpr = new AssignmentExpression(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.LOR:
returnExpr = new LogicalOr(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.LAND:
returnExpr = new LogicalAnd(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.BXOR:
returnExpr = new LogicalXor(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.NOT_EQUAL:
returnExpr = new NotEqual(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.EQUAL:
returnExpr = new Equal(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.LT:
returnExpr = new Less(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.GT:
returnExpr = new Greater(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.LE:
returnExpr = new LessOrEqual(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.GE:
returnExpr = new GreaterOrEqual(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.PLUS:
returnExpr = new Addition(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.MINUS:
returnExpr = new Subtraction(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.DIV:
returnExpr = new Division(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.STAR:
returnExpr = new Product(exprList, validateExpr);
break;
}
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createExpression");
return returnExpr;
}
public static Expression createExpression(Expression e1, int type,
SPLSymbolTable sTab) throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createExpression");
Expression returnExpr = null;
List exprList = new ArrayList(1); // DAW
exprList.add(e1);
boolean validateExpr = true;
if (sTab.getSymbolTableType() == SPLSymbolTable.COLLECT)
{
validateExpr = false;
}
switch (type)
{
case SPLTreeParserTokenTypes.UNARY_MINUS:
returnExpr = new UnaryMinusExpression(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.UNARY_PLUS:
returnExpr = new UnaryPlusExpression(exprList, validateExpr);
break;
case SPLTreeParserTokenTypes.UNARY_NOT:
//Xiping 06/12/08
//returnExpr = new UnaryNotExpression(exprList, validateExpr);
returnExpr = new LogicalNot(exprList, validateExpr);
}
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createExpression");
return returnExpr;
}
public static Expression createExpression(String val, int type)
throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createExpression");
Expression returnExpr = null;
switch (type)
{
case TypeConstants.dateTime:
// System.out.println("Expression factory creating new date time: "+
// val.toString());
returnExpr = new DateTimeConstant(val);
break;
case TypeConstants.charType:
char[] cArr = val.toCharArray();
returnExpr = new CharConstant(cArr[0]);
break;
case TypeConstants.doubleType:
returnExpr = new DoubleConstant(Double.valueOf(val).doubleValue());
break;
case TypeConstants.floatType:
returnExpr = new FloatConstant(Float.valueOf(val).floatValue());
break;
case TypeConstants.intType:
returnExpr = new IntegerConstant(Integer.valueOf(val).intValue());
break;
case TypeConstants.shortType:
returnExpr = new ShortConstant(Short.valueOf(val).shortValue());
break;
case TypeConstants.longType:
if (val.endsWith("L") || val.endsWith("l"))
{
val = val.substring(0, val.length() - 2);
}
returnExpr = new LongConstant(Long.valueOf(val).longValue());
break;
case TypeConstants.stringType:
String dateStr = (String) val;
if (DateTime.isDateTimeString(dateStr))
{
// System.out.println("string is a date string
// createJavaDateTime "+val);
int size = dateStr.length();
returnExpr = new DateTimeConstant(dateStr
.substring(1, size - 1));
}
else
{
returnExpr = new StringConstant(val);
}
break;
case TypeConstants.booleanType:
returnExpr = new BooleanConstant(Boolean.valueOf(val)
.booleanValue());
break;
/*
* case TypeConstants.referenceType : try { returnExpr = new
* SelfExpression(); } catch (NonExistentSymbolException e) { // TODO
* Auto-generated catch block e.printStackTrace(); } catch
* (IllegalSymbolReferenceException e) { // TODO Auto-generated catch
* block e.printStackTrace(); } catch (IllegalExpressionTypeException e) { //
* TODO Auto-generated catch block e.printStackTrace(); } break;
*/
}
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createExpression");
return returnExpr;
}
public static Expression createSelfExpression(SPLSymbolTable st)
throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createSelfExpression");
Expression expression = new SelfExpression(st);
//System.out.println("created self expression " + expression.toString());
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createSelfExpression");
return expression;
}
public static Expression createCollectExpression(ArrayList pList,
Expression postCollect, SPLSymbolTable sTab) throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createCollectExpression");
Expression returnExpr = null;
returnExpr = new CollectOperation(pList, postCollect, sTab);
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createCollectExpression");
return returnExpr;
}
// exp =
// ExpressionFactory.createPostCollectExpression(id.getText(),arrExp,pList);
public static Expression createPostCollectExpression(Expression arr1,
String propOrMethodName, Expression arrExp, ArrayList pList,
SPLSymbolTable sTab) throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createPostCollectExpression");
Expression returnExpr = null;
returnExpr = new PostCollectExpression(arr1, propOrMethodName, arrExp,
pList, sTab);
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createPostCollectExpression");
return returnExpr;
}
public static Expression createBasicCollectExpression(ArrayList pList,
SPLSymbolTable sTab) throws SPLException
{
logger.entering(sourceClass, Thread.currentThread().getName() + " "
+ "createBasicCollectExpression");
Expression returnExpr = null;
returnExpr = new BasicCollectionExpression(pList, sTab);
if (returnExpr == null)
{
logger
.severe(Thread.currentThread().getName()
+ " "
+ "Constructor BasicCollectionExpression(pList,sTab) returned null expression");
throw new SPLException(Messages
.getString("SPL_EXPRESSION_FACTORY_EXCEPTION1_MSG"));
}
logger.exiting(sourceClass, Thread.currentThread().getName() + " "
+ "createBasicCollectExpression");
return returnExpr;
}
public static Expression createExpression(String classOrOperationName,
List paramOrIdentTupleList, boolean isBuiltInOperation,
SPLSymbolTable symTab) throws SPLException
{
Expression returnExpr = null;
if (isBuiltInOperation)
{
//System.out.println("isBuiltInOperation=true ");
if (symTab == null)
{
//System.out.println("ExpressionFactory : symTab is null ");
}
returnExpr = BuitInOperationExpressionFactory.createExpression(
classOrOperationName, "", paramOrIdentTupleList, symTab);
}
else
{
//System.out.println("isBuiltInOperation=false "+classOrOperationName);
if (symTab == null)
{
//System.out.println("ExpressionFactory : symTab is null ");
}
returnExpr = new PrimaryExpression(classOrOperationName,
paramOrIdentTupleList, symTab);
}
return returnExpr;
}
/*
* public static Expression createExpression(String className, String
* methodOrPropName, Expression arrExp, List pList, boolean isMethod,
* SPLSymbolTable sTab) throws SPLException {
* logger.entering(sourceClass,Thread.currentThread().getName()+" "+
* "createExpression");
*
* Expression returnExpr = null;
*
* if (isMethod) {
*
* returnExpr = BuitInOperationExpressionFactory.createExpression(className,
* methodOrPropName, pList, sTab);
* } else {
*
* returnExpr = new PrimaryExpression(className, methodOrPropName, arrExp,
* sTab);
* }
*
*
* logger.exiting(sourceClass,Thread.currentThread().getName()+" "+
* "createExpression");
*
* return returnExpr;
* }
*/
}