diff --git a/org.springframework.expression/.project b/org.springframework.expression/.project index e32b16b73fb..9d8538bf2b2 100644 --- a/org.springframework.expression/.project +++ b/org.springframework.expression/.project @@ -12,8 +12,14 @@ + + structure101.java.eclipse.plugin.JDMEclipseBuilder + + + org.eclipse.jdt.core.javanature + structure101.java.eclipse.plugin.JDMEclipseNature diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/Expression.java b/org.springframework.expression/src/main/java/org/springframework/expression/Expression.java index 21b69ffb3eb..45c8daacea9 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/Expression.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/Expression.java @@ -41,7 +41,7 @@ public interface Expression { * @return the evaluation result * @throws EvaluationException if there is a problem during evaluation */ - public Object getValue(Class desiredResultType) throws EvaluationException; + public T getValue(Class desiredResultType) throws EvaluationException; /** * Evaluate this expression in the provided context and return the result of evaluation. @@ -62,7 +62,7 @@ public interface Expression { * @return the evaluation result * @throws EvaluationException if there is a problem during evaluation */ - public Object getValue(EvaluationContext context, Class desiredResultType) throws EvaluationException; + public T getValue(EvaluationContext context, Class desiredResultType) throws EvaluationException; /** * Set this expression in the provided context to the value provided. diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/common/CompositeStringExpression.java b/org.springframework.expression/src/main/java/org/springframework/expression/common/CompositeStringExpression.java index 6e963c13672..b55d67608d4 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/common/CompositeStringExpression.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/common/CompositeStringExpression.java @@ -62,14 +62,14 @@ public class CompositeStringExpression implements Expression { throw new EvaluationException(expressionString, "Cannot call setValue() on a composite expression"); } - public Object getValue(EvaluationContext context, Class expectedResultType) throws EvaluationException { + public T getValue(EvaluationContext context, Class expectedResultType) throws EvaluationException { Object value = getValue(context); - return ExpressionUtils.convert(context, value, expectedResultType); + return (T)ExpressionUtils.convert(context, value, expectedResultType); } - public Object getValue(Class expectedResultType) throws EvaluationException { + public T getValue(Class expectedResultType) throws EvaluationException { Object value = getValue(); - return ExpressionUtils.convert(null, value, expectedResultType); + return (T)ExpressionUtils.convert(null, value, expectedResultType); } public boolean isWritable(EvaluationContext context) throws EvaluationException { diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java b/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java index dfb49cf35fb..8abb0af12c2 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/common/LiteralExpression.java @@ -44,14 +44,14 @@ public class LiteralExpression implements Expression { throw new EvaluationException(literalValue, "Cannot call setValue() on a LiteralExpression"); } - public Object getValue(EvaluationContext context, Class expectedResultType) throws EvaluationException { + public T getValue(EvaluationContext context, Class expectedResultType) throws EvaluationException { Object value = getValue(context); - return ExpressionUtils.convert(context, value, expectedResultType); + return (T)ExpressionUtils.convert(context, value, expectedResultType); } - public Object getValue(Class expectedResultType) throws EvaluationException { + public T getValue(Class expectedResultType) throws EvaluationException { Object value = getValue(); - return ExpressionUtils.convert(null, value, expectedResultType); + return (T)ExpressionUtils.convert(null, value, expectedResultType); } public boolean isWritable(EvaluationContext context) throws EvaluationException { diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java index 74d69e9d00e..e897745206f 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ExpressionState.java @@ -15,6 +15,7 @@ */ package org.springframework.expression.spel; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Stack; @@ -27,7 +28,6 @@ import org.springframework.expression.PropertyAccessor; import org.springframework.expression.TypeComparator; import org.springframework.expression.TypeConverter; import org.springframework.expression.TypeUtils; -import org.springframework.expression.spel.internal.VariableScope; /** * An ExpressionState is for maintaining per-expression-evaluation state, any changes to it are not seen by other @@ -199,4 +199,42 @@ public class ExpressionState { return relatedContext; } + /** + * A new scope is entered when a function is called and it is used to hold the parameters to the function call. If the names + * of the parameters clash with those in a higher level scope, those in the higher level scope will not be accessible whilst + * the function is executing. When the function returns the scope is exited. + * + * @author Andy Clement + * + */ + static class VariableScope { + + private final Map vars = new HashMap(); + + public VariableScope() { } + + public VariableScope(Map arguments) { + if (arguments!=null) { + vars.putAll(arguments); + } + } + + public VariableScope(String name,Object value) { + vars.put(name,value); + } + + public Object lookupVariable(String name) { + return vars.get(name); + } + + public void setVariable(String name, Object value) { + vars.put(name,value); + } + + public boolean definesVariable(String name) { + return vars.containsKey(name); + } + + } + } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpression.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpression.java index 356bd00e4c2..0c3a01a430d 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpression.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpression.java @@ -19,8 +19,6 @@ import org.springframework.expression.EvaluationContext; import org.springframework.expression.EvaluationException; import org.springframework.expression.Expression; import org.springframework.expression.common.ExpressionUtils; -import org.springframework.expression.spel.ast.SpelNode; -import org.springframework.expression.spel.standard.StandardEvaluationContext; /** * A SpelExpressions represents a parsed (valid) expression that is ready to be evaluated in a specified context. An @@ -31,6 +29,7 @@ import org.springframework.expression.spel.standard.StandardEvaluationContext; * */ public class SpelExpression implements Expression { + private final String expression; public final SpelNode ast; @@ -40,7 +39,7 @@ public class SpelExpression implements Expression { * @param expression * @param ast */ - SpelExpression(String expression, SpelNode ast) { + public SpelExpression(String expression, SpelNode ast) { this.expression = expression; this.ast = ast; } @@ -56,8 +55,7 @@ public class SpelExpression implements Expression { * {@inheritDoc} */ public Object getValue() throws EvaluationException { - EvaluationContext eContext = new StandardEvaluationContext(); - return ast.getValue(new ExpressionState(eContext)); + return ast.getValue(null); } /** @@ -70,18 +68,17 @@ public class SpelExpression implements Expression { /** * {@inheritDoc} */ - public Object getValue(EvaluationContext context, Class expectedResultType) throws EvaluationException { + public T getValue(EvaluationContext context, Class expectedResultType) throws EvaluationException { Object result = ast.getValue(new ExpressionState(context)); if (result != null && expectedResultType != null) { Class resultType = result.getClass(); - if (expectedResultType.isAssignableFrom(resultType)) { - return result; + if (!expectedResultType.isAssignableFrom(resultType)) { + // Attempt conversion to the requested type, may throw an exception + result = context.getTypeUtils().getTypeConverter().convertValue(result, expectedResultType); } - // Attempt conversion to the requested type, may throw an exception - return context.getTypeUtils().getTypeConverter().convertValue(result, expectedResultType); } - return result; + return (T)result; } /** @@ -145,9 +142,10 @@ public class SpelExpression implements Expression { /** * {@inheritDoc} */ - public Object getValue(Class expectedResultType) throws EvaluationException { + public T getValue(Class expectedResultType) throws EvaluationException { Object result = getValue(); - return ExpressionUtils.convert(null, result, expectedResultType); + // TODO propagate generic-ness into convert + return (T)ExpressionUtils.convert(null, result, expectedResultType); } } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpressionParser.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpressionParser.java index 733e72062b2..27cfadc8a3b 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpressionParser.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelExpressionParser.java @@ -15,21 +15,12 @@ */ package org.springframework.expression.spel; -import org.antlr.runtime.ANTLRStringStream; -import org.antlr.runtime.CommonTokenStream; -import org.antlr.runtime.RecognitionException; import org.springframework.expression.Expression; import org.springframework.expression.ParseException; import org.springframework.expression.ParserContext; import org.springframework.expression.common.DefaultNonTemplateParserContext; import org.springframework.expression.common.TemplateAwareExpressionParser; -import org.springframework.expression.spel.ast.SpelNode; -import org.springframework.expression.spel.generated.SpringExpressionsLexer; -import org.springframework.expression.spel.generated.SpringExpressionsParser.expr_return; -import org.springframework.expression.spel.internal.InternalELException; -import org.springframework.expression.spel.internal.SpelTreeAdaptor; -import org.springframework.expression.spel.internal.SpringExpressionsLexerExtender; -import org.springframework.expression.spel.internal.SpringExpressionsParserExtender; +import org.springframework.expression.spel.antlr.SpelAntlrExpressionParser; /** * Instances of this parser class can process Spring Expression Language format expressions. The result of parsing an @@ -40,17 +31,11 @@ import org.springframework.expression.spel.internal.SpringExpressionsParserExten */ public class SpelExpressionParser extends TemplateAwareExpressionParser { - private final SpringExpressionsLexer lexer; - private final SpringExpressionsParserExtender parser; + private final SpelInternalParser expressionParser; - /** - * Should be constructed through the SpelParserFactory - */ public SpelExpressionParser() { - lexer = new SpringExpressionsLexerExtender(); - CommonTokenStream tokens = new CommonTokenStream(lexer); - parser = new SpringExpressionsParserExtender(tokens); - parser.setTreeAdaptor(new SpelTreeAdaptor()); + // Use an Antlr based expression parser + expressionParser = new SpelAntlrExpressionParser(); } /** @@ -63,22 +48,7 @@ public class SpelExpressionParser extends TemplateAwareExpressionParser { */ @Override protected Expression doParseExpression(String expressionString, ParserContext context) throws ParseException { - try { - lexer.setCharStream(new ANTLRStringStream(expressionString)); - CommonTokenStream tokens = new CommonTokenStream(lexer); - parser.setTokenStream(tokens); - expr_return exprReturn = parser.expr(); - SpelExpression newExpression = new SpelExpression(expressionString, (SpelNode) exprReturn.getTree()); - return newExpression; - } catch (RecognitionException re) { - ParseException exception = new ParseException(expressionString, "Recognition error at position: " - + re.charPositionInLine + ": " + re.getMessage(), re); - throw exception; - } catch (InternalELException e) { - SpelException wrappedException = e.getCause(); - throw new ParseException(expressionString, "Parsing problem: " + wrappedException.getMessage(), - wrappedException); - } + return expressionParser.doParseExpression(expressionString,context); } /** @@ -88,4 +58,8 @@ public class SpelExpressionParser extends TemplateAwareExpressionParser { public SpelExpression parseExpression(String expressionString) throws ParseException { return (SpelExpression) super.parseExpression(expressionString, DefaultNonTemplateParserContext.INSTANCE); } + + public interface SpelInternalParser { + Expression doParseExpression(String expressionString, ParserContext context) throws ParseException; + } } \ No newline at end of file diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java index 6e8ad8b48f7..9529e6f24b0 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/SpelUtilities.java @@ -17,8 +17,6 @@ package org.springframework.expression.spel; import java.io.PrintStream; -import org.springframework.expression.spel.ast.SpelNode; - /** * Utilities for working with Spring Expressions. * @@ -45,10 +43,9 @@ public class SpelUtilities { private static void printAST(PrintStream out, SpelNode t, String indent) { if (t != null) { StringBuilder sb = new StringBuilder(); - String s = (t.getType() == -1 ? "EOF" : t.getClass().getSimpleName()); - sb.append(indent).append(s); - sb.append(" value=").append(t.getText()); - sb.append(t.getChildCount() < 2 ? "" : " children=#" + t.getChildCount()); + sb.append(indent).append(t.getClass().getSimpleName()); + sb.append(" value:").append(t.toStringAST()); + sb.append(t.getChildCount() < 2 ? "" : " #children:" + t.getChildCount()); out.println(sb.toString()); for (int i = 0; i < t.getChildCount(); i++) { printAST(out, t.getChild(i), indent + " "); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Assign.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Assign.java index 18c7dbeaab1..719516c1c1e 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Assign.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Assign.java @@ -28,15 +28,15 @@ import org.springframework.expression.spel.ExpressionState; * @author Andy Clement * */ -public class Assign extends SpelNode { +public class Assign extends SpelNodeImpl { public Assign(Token payload) { super(payload); } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object newValue = getChild(1).getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object newValue = getChild(1).getValueInternal(state); getChild(0).setValue(state, newValue); return newValue; } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java index eb95853c541..cad04cf8fe5 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/CompoundExpression.java @@ -26,7 +26,7 @@ import org.springframework.expression.spel.ExpressionState; * @author Andy Clement * */ -public class CompoundExpression extends SpelNode { +public class CompoundExpression extends SpelNodeImpl { public CompoundExpression(Token payload) { super(payload); @@ -40,17 +40,17 @@ public class CompoundExpression extends SpelNode { * @return the final value from the last piece of the compound expression */ @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Object result = null; - SpelNode nextNode = null; + SpelNodeImpl nextNode = null; try { nextNode = getChild(0); - result = nextNode.getValue(state); + result = nextNode.getValueInternal(state); for (int i = 1; i < getChildCount(); i++) { try { state.pushActiveContextObject(result); nextNode = getChild(i); - result = nextNode.getValue(state); + result = nextNode.getValueInternal(state); } finally { state.popActiveContextObject(); } @@ -69,11 +69,11 @@ public class CompoundExpression extends SpelNode { getChild(0).setValue(state, value); return; } - Object ctx = getChild(0).getValue(state); + Object ctx = getChild(0).getValueInternal(state); for (int i = 1; i < getChildCount() - 1; i++) { try { state.pushActiveContextObject(ctx); - ctx = getChild(i).getValue(state); + ctx = getChild(i).getValueInternal(state); } finally { state.popActiveContextObject(); } @@ -91,11 +91,11 @@ public class CompoundExpression extends SpelNode { if (getChildCount() == 1) { return getChild(0).isWritable(state); } - Object ctx = getChild(0).getValue(state); + Object ctx = getChild(0).getValueInternal(state); for (int i = 1; i < getChildCount() - 1; i++) { try { state.pushActiveContextObject(ctx); - ctx = getChild(i).getValue(state); + ctx = getChild(i).getValueInternal(state); } finally { state.popActiveContextObject(); } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java index 069fa0fa92d..89681b28f73 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java @@ -42,7 +42,7 @@ import org.springframework.expression.spel.internal.Utils; * @author Andy Clement * */ -public class ConstructorReference extends SpelNode { +public class ConstructorReference extends SpelNodeImpl { /** * The resolver/executor model {@link ConstructorResolver} supports the caching of executor objects that can run @@ -71,7 +71,7 @@ public class ConstructorReference extends SpelNode { * Implements getValue() - delegating to the code for building an array or a simple type. */ @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { if (isArrayConstructor) { return createArray(state); } else { @@ -99,7 +99,7 @@ public class ConstructorReference extends SpelNode { // Next child is EXPRESSIONLIST token with children that are the // expressions giving array size sb.append("["); - SpelNode arrayRank = getChild(index++); + SpelNodeImpl arrayRank = getChild(index++); for (int i = 0; i < arrayRank.getChildCount(); i++) { if (i > 0) sb.append(","); @@ -126,7 +126,7 @@ public class ConstructorReference extends SpelNode { * @throws EvaluationException if there is a problem creating the array */ private Object createArray(ExpressionState state) throws EvaluationException { - Object intendedArrayType = getChild(0).getValue(state); + Object intendedArrayType = getChild(0).getValueInternal(state); if (!(intendedArrayType instanceof String)) { throw new SpelException(getChild(0).getCharPositionInLine(), SpelMessages.TYPE_NAME_EXPECTED_FOR_ARRAY_CONSTRUCTION, Utils @@ -155,7 +155,7 @@ public class ConstructorReference extends SpelNode { // Array ranks are specified but is it a single or multiple dimension array? int dimensions = getChild(1).getChildCount(); if (dimensions == 1) { - Object o = getChild(1).getValue(state); + Object o = getChild(1).getValueInternal(state); int arraySize = state.toInteger(o); if (getChildCount() == 3) { // Check initializer length matches array size length @@ -170,7 +170,7 @@ public class ConstructorReference extends SpelNode { // Multi-dimensional - hold onto your hat ! int[] dims = new int[dimensions]; for (int d = 0; d < dimensions; d++) { - dims[d] = state.toInteger(getChild(1).getChild(d).getValue(state)); + dims[d] = state.toInteger(getChild(1).getChild(d).getValueInternal(state)); } newArray = Array.newInstance(componentType, dims); // TODO check any specified initializer for the multidim array matches @@ -179,12 +179,12 @@ public class ConstructorReference extends SpelNode { // Populate the array using the initializer if one is specified if (getChildCount() == 3) { - SpelNode initializer = getChild(2); + SpelNodeImpl initializer = getChild(2); if (arrayTypeCode == TypeCode.OBJECT) { Object[] newObjectArray = (Object[]) newArray; for (int i = 0; i < newObjectArray.length; i++) { - SpelNode elementNode = initializer.getChild(i); - Object arrayEntry = elementNode.getValue(state); + SpelNodeImpl elementNode = initializer.getChild(i); + Object arrayEntry = elementNode.getValueInternal(state); if (!componentType.isAssignableFrom(arrayEntry.getClass())) { throw new SpelException(elementNode.getCharPositionInLine(), SpelMessages.INCORRECT_ELEMENT_TYPE_FOR_ARRAY, componentType.getName(), arrayEntry @@ -195,42 +195,42 @@ public class ConstructorReference extends SpelNode { } else if (arrayTypeCode == TypeCode.INT) { int[] newIntArray = (int[]) newArray; for (int i = 0; i < newIntArray.length; i++) { - newIntArray[i] = state.toInteger(initializer.getChild(i).getValue(state)); + newIntArray[i] = state.toInteger(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.BOOLEAN) { boolean[] newBooleanArray = (boolean[]) newArray; for (int i = 0; i < newBooleanArray.length; i++) { - newBooleanArray[i] = state.toBoolean(initializer.getChild(i).getValue(state)); + newBooleanArray[i] = state.toBoolean(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.CHAR) { char[] newCharArray = (char[]) newArray; for (int i = 0; i < newCharArray.length; i++) { - newCharArray[i] = state.toCharacter(initializer.getChild(i).getValue(state)); + newCharArray[i] = state.toCharacter(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.SHORT) { short[] newShortArray = (short[]) newArray; for (int i = 0; i < newShortArray.length; i++) { - newShortArray[i] = state.toShort(initializer.getChild(i).getValue(state)); + newShortArray[i] = state.toShort(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.LONG) { long[] newLongArray = (long[]) newArray; for (int i = 0; i < newLongArray.length; i++) { - newLongArray[i] = state.toLong(initializer.getChild(i).getValue(state)); + newLongArray[i] = state.toLong(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.FLOAT) { float[] newFloatArray = (float[]) newArray; for (int i = 0; i < newFloatArray.length; i++) { - newFloatArray[i] = state.toFloat(initializer.getChild(i).getValue(state)); + newFloatArray[i] = state.toFloat(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.DOUBLE) { double[] newDoubleArray = (double[]) newArray; for (int i = 0; i < newDoubleArray.length; i++) { - newDoubleArray[i] = state.toDouble(initializer.getChild(i).getValue(state)); + newDoubleArray[i] = state.toDouble(initializer.getChild(i).getValueInternal(state)); } } else if (arrayTypeCode == TypeCode.BYTE) { byte[] newByteArray = (byte[]) newArray; for (int i = 0; i < newByteArray.length; i++) { - newByteArray[i] = state.toByte(initializer.getChild(i).getValue(state)); + newByteArray[i] = state.toByte(initializer.getChild(i).getValueInternal(state)); } } } @@ -249,7 +249,7 @@ public class ConstructorReference extends SpelNode { Object[] arguments = new Object[getChildCount() - 1]; Class[] argumentTypes = new Class[getChildCount() - 1]; for (int i = 0; i < arguments.length; i++) { - Object childValue = getChild(i + 1).getValue(state); + Object childValue = getChild(i + 1).getValueInternal(state); arguments[i] = childValue; argumentTypes[i] = childValue.getClass(); } @@ -264,7 +264,7 @@ public class ConstructorReference extends SpelNode { } // either there was no accessor or it no longer exists - String typename = (String) getChild(0).getValue(state); + String typename = (String) getChild(0).getValueInternal(state); cachedExecutor = findExecutorForConstructor(typename, argumentTypes, state); try { return cachedExecutor.execute(state.getEvaluationContext(), arguments); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Dot.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Dot.java index 6231a4a13ee..e620dfc9797 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Dot.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Dot.java @@ -25,7 +25,7 @@ import org.springframework.expression.spel.ExpressionState; * @author Andy Clement * */ -public class Dot extends SpelNode { +public class Dot extends SpelNodeImpl { // TODO Keep Dot for the positional information or remove it? public Dot(Token payload) { @@ -38,7 +38,7 @@ public class Dot extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws SpelException { + public Object getValueInternal(ExpressionState state) throws SpelException { // This makes Dot a do-nothing operation, but this is not free in terms of computation return state.getActiveContextObject(); } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java index 185deb055c2..e34ed4064e2 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java @@ -39,7 +39,7 @@ import org.springframework.expression.spel.reflection.ReflectionUtils; * * @author Andy Clement */ -public class FunctionReference extends SpelNode { +public class FunctionReference extends SpelNodeImpl { private final String name; @@ -49,7 +49,7 @@ public class FunctionReference extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Object o = state.lookupVariable(name); if (o == null) { throw new SpelException(SpelMessages.FUNCTION_NOT_DEFINED, name); @@ -139,7 +139,7 @@ public class FunctionReference extends SpelNode { // Compute arguments to the function Object[] arguments = new Object[getChildCount()]; for (int i = 0; i < arguments.length; i++) { - arguments[i] = getChild(i).getValue(state); + arguments[i] = getChild(i).getValueInternal(state); } return arguments; } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Identifier.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Identifier.java index 65510c5aaca..54cb182586f 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Identifier.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Identifier.java @@ -19,7 +19,7 @@ import org.antlr.runtime.Token; import org.springframework.expression.spel.SpelException; import org.springframework.expression.spel.ExpressionState; -public class Identifier extends SpelNode { +public class Identifier extends SpelNodeImpl { private final String id; @@ -34,7 +34,7 @@ public class Identifier extends SpelNode { } @Override - public String getValue(ExpressionState state) throws SpelException { + public String getValueInternal(ExpressionState state) throws SpelException { return id; } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java index 8ed93fc9dc7..e784e0c367c 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java @@ -32,16 +32,16 @@ import org.springframework.expression.spel.SpelMessages; * * @author Andy Clement */ -public class Indexer extends SpelNode { +public class Indexer extends SpelNodeImpl { public Indexer(Token payload) { super(payload); } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Object ctx = state.getActiveContextObject(); - Object index = getChild(0).getValue(state); + Object index = getChild(0).getValueInternal(state); // Indexing into a Map if (ctx instanceof Map) { diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Literal.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Literal.java index 094b76ac13d..01ba7f1ec30 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Literal.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Literal.java @@ -19,7 +19,7 @@ import org.antlr.runtime.Token; import org.springframework.expression.spel.ExpressionState; import org.springframework.expression.spel.SpelException; import org.springframework.expression.spel.SpelMessages; -import org.springframework.expression.spel.internal.InternalELException; +import org.springframework.expression.spel.WrappedELException; /** * Common superclass for nodes representing literals (boolean, string, number, etc). @@ -27,7 +27,7 @@ import org.springframework.expression.spel.internal.InternalELException; * @author Andy Clement * */ -public abstract class Literal extends SpelNode { +public abstract class Literal extends SpelNodeImpl { public Literal(Token payload) { super(payload); @@ -36,7 +36,7 @@ public abstract class Literal extends SpelNode { public abstract Object getLiteralValue(); @Override - public final Object getValue(ExpressionState state) throws SpelException { + public final Object getValueInternal(ExpressionState state) throws SpelException { return getLiteralValue(); } @@ -84,7 +84,7 @@ public abstract class Literal extends SpelNode { long value = Long.parseLong(numberString, radix); return new LongLiteral(numberToken, value); } catch (NumberFormatException nfe) { - throw new InternalELException(new SpelException(numberToken.getCharPositionInLine(), nfe, + throw new WrappedELException(new SpelException(numberToken.getCharPositionInLine(), nfe, SpelMessages.NOT_A_LONG, numberToken.getText())); } } else { @@ -92,7 +92,7 @@ public abstract class Literal extends SpelNode { int value = Integer.parseInt(numberString, radix); return new IntLiteral(numberToken, value); } catch (NumberFormatException nfe) { - throw new InternalELException(new SpelException(numberToken.getCharPositionInLine(), nfe, + throw new WrappedELException(new SpelException(numberToken.getCharPositionInLine(), nfe, SpelMessages.NOT_AN_INTEGER, numberToken.getText())); } } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java index 36b6694e90c..22f3af34eaa 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/MethodReference.java @@ -28,7 +28,7 @@ import org.springframework.expression.spel.SpelException; import org.springframework.expression.spel.SpelMessages; import org.springframework.expression.spel.internal.Utils; -public class MethodReference extends SpelNode { +public class MethodReference extends SpelNodeImpl { private final String name; private MethodExecutor fastInvocationAccessor; @@ -39,11 +39,11 @@ public class MethodReference extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Object currentContext = state.getActiveContextObject(); Object[] arguments = new Object[getChildCount()]; for (int i = 0; i < arguments.length; i++) { - arguments[i] = getChild(i).getValue(state); + arguments[i] = getChild(i).getValueInternal(state); } if (currentContext == null) { throw new SpelException(getCharPositionInLine(), SpelMessages.ATTEMPTED_METHOD_CALL_ON_NULL_CONTEXT_OBJECT, diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Operator.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Operator.java index 10819c419fd..b77139f739b 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Operator.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Operator.java @@ -25,7 +25,7 @@ import org.springframework.expression.spel.ExpressionState; * * @author Andy Clement */ -public abstract class Operator extends SpelNode { +public abstract class Operator extends SpelNodeImpl { public Operator(Token payload) { super(payload); @@ -39,11 +39,11 @@ public abstract class Operator extends SpelNode { return false; } - public SpelNode getLeftOperand() { + public SpelNodeImpl getLeftOperand() { return getChild(0); } - public SpelNode getRightOperand() { + public SpelNodeImpl getRightOperand() { return getChild(1); } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorAnd.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorAnd.java index 6ef1006c437..55726e3135c 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorAnd.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorAnd.java @@ -37,12 +37,12 @@ public class OperatorAnd extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { boolean leftValue; boolean rightValue; try { - leftValue = state.toBoolean(getLeftOperand().getValue(state)); + leftValue = state.toBoolean(getLeftOperand().getValueInternal(state)); } catch (SpelException ee) { ee.setPosition(getLeftOperand().getCharPositionInLine()); throw ee; @@ -53,7 +53,7 @@ public class OperatorAnd extends Operator { } try { - rightValue = state.toBoolean(getRightOperand().getValue(state)); + rightValue = state.toBoolean(getRightOperand().getValueInternal(state)); } catch (SpelException ee) { ee.setPosition(getRightOperand().getCharPositionInLine()); throw ee; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorBetween.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorBetween.java index 842ac945085..ff6793e5db5 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorBetween.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorBetween.java @@ -51,9 +51,9 @@ public class OperatorBetween extends Operator { * @throws EvaluationException if there is a problem evaluating the expression */ @Override - public Boolean getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Boolean getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (!(right instanceof List) || ((List) right).size() != 2) { throw new SpelException(getRightOperand().getCharPositionInLine(), SpelMessages.BETWEEN_RIGHT_OPERAND_MUST_BE_TWO_ELEMENT_LIST); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorDivide.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorDivide.java index a594ba3ae79..6b9b913072a 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorDivide.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorDivide.java @@ -37,9 +37,9 @@ public class OperatorDivide extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object operandOne = getLeftOperand().getValue(state); - Object operandTwo = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object operandOne = getLeftOperand().getValueInternal(state); + Object operandTwo = getRightOperand().getValueInternal(state); if (operandOne instanceof Number && operandTwo instanceof Number) { Number op1 = (Number) operandOne; Number op2 = (Number) operandTwo; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorEquality.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorEquality.java index 15c59db05ef..8eb1ce3a64b 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorEquality.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorEquality.java @@ -36,9 +36,9 @@ public class OperatorEquality extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThan.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThan.java index 4600f4ba849..5a8168cddc5 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThan.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThan.java @@ -36,9 +36,9 @@ public class OperatorGreaterThan extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThanOrEqual.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThanOrEqual.java index 0c840c254aa..ae03223950a 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThanOrEqual.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorGreaterThanOrEqual.java @@ -36,9 +36,9 @@ public class OperatorGreaterThanOrEqual extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInequality.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInequality.java index 2ba0a94ac94..ee02fe1eaf2 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInequality.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInequality.java @@ -36,9 +36,9 @@ public class OperatorInequality extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInstanceof.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInstanceof.java index 29a457ddcfc..56af41a78f3 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInstanceof.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorInstanceof.java @@ -47,9 +47,9 @@ public class OperatorInstanceof extends Operator { * @throws EvaluationException if there is a problem evaluating the expression */ @Override - public Boolean getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Boolean getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left == null) { return false; // null is not an instanceof anything } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThan.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThan.java index dfdd6d99349..fd3ab2c9aee 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThan.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThan.java @@ -36,9 +36,9 @@ public class OperatorLessThan extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThanOrEqual.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThanOrEqual.java index 66ad8c1ba59..a984b87680f 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThanOrEqual.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorLessThanOrEqual.java @@ -31,9 +31,9 @@ public class OperatorLessThanOrEqual extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object left = getLeftOperand().getValue(state); - Object right = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object left = getLeftOperand().getValueInternal(state); + Object right = getRightOperand().getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMatches.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMatches.java index 6445569b16b..6618f2cc35e 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMatches.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMatches.java @@ -50,11 +50,11 @@ public class OperatorMatches extends Operator { * @throws EvaluationException if there is a problem evaluating the expression (e.g. the regex is invalid) */ @Override - public Boolean getValue(ExpressionState state) throws EvaluationException { - SpelNode leftOp = getLeftOperand(); - SpelNode rightOp = getRightOperand(); + public Boolean getValueInternal(ExpressionState state) throws EvaluationException { + SpelNodeImpl leftOp = getLeftOperand(); + SpelNodeImpl rightOp = getRightOperand(); Object left = leftOp.getValue(state, String.class); - Object right = getRightOperand().getValue(state); + Object right = getRightOperand().getValueInternal(state); try { if (!(left instanceof String)) { throw new SpelException(leftOp.getCharPositionInLine(), diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMinus.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMinus.java index dea69a22dad..6366590b0aa 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMinus.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMinus.java @@ -18,9 +18,9 @@ package org.springframework.expression.spel.ast; import org.antlr.runtime.Token; import org.springframework.expression.EvaluationException; import org.springframework.expression.Operation; +import org.springframework.expression.spel.ExpressionState; import org.springframework.expression.spel.SpelException; import org.springframework.expression.spel.SpelMessages; -import org.springframework.expression.spel.ExpressionState; /** * Implements the minus operator. If there is only one operand it is a unary minus. @@ -47,11 +47,11 @@ public class OperatorMinus extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - SpelNode leftOp = getLeftOperand(); - SpelNode rightOp = getRightOperand(); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + SpelNodeImpl leftOp = getLeftOperand(); + SpelNodeImpl rightOp = getRightOperand(); if (rightOp == null) {// If only one operand, then this is unary minus - Object left = leftOp.getValue(state); + Object left = leftOp.getValueInternal(state); if (left instanceof Number) { Number n = (Number) left; if (left instanceof Double) { @@ -70,8 +70,8 @@ public class OperatorMinus extends Operator { } throw new SpelException(SpelMessages.CANNOT_NEGATE_TYPE, left.getClass().getName()); } else { - Object left = leftOp.getValue(state); - Object right = rightOp.getValue(state); + Object left = leftOp.getValueInternal(state); + Object right = rightOp.getValueInternal(state); if (left instanceof Number && right instanceof Number) { Number op1 = (Number) left; Number op2 = (Number) right; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorModulus.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorModulus.java index 7e33f1aa4f0..070d467d325 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorModulus.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorModulus.java @@ -37,9 +37,9 @@ public class OperatorModulus extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object operandOne = getLeftOperand().getValue(state); - Object operandTwo = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object operandOne = getLeftOperand().getValueInternal(state); + Object operandTwo = getRightOperand().getValueInternal(state); if (operandOne instanceof Number && operandTwo instanceof Number) { Number op1 = (Number) operandOne; Number op2 = (Number) operandTwo; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMultiply.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMultiply.java index 5d7130e44f1..e7f02acf746 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMultiply.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorMultiply.java @@ -48,9 +48,9 @@ public class OperatorMultiply extends Operator { * */ @Override - public Object getValue(ExpressionState state) throws EvaluationException { - Object operandOne = getLeftOperand().getValue(state); - Object operandTwo = getRightOperand().getValue(state); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + Object operandOne = getLeftOperand().getValueInternal(state); + Object operandTwo = getRightOperand().getValueInternal(state); if (operandOne instanceof Number && operandTwo instanceof Number) { Number op1 = (Number) operandOne; Number op2 = (Number) operandTwo; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorNot.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorNot.java index 78513dbc966..aa5d1f35e57 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorNot.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorNot.java @@ -20,16 +20,16 @@ import org.springframework.expression.EvaluationException; import org.springframework.expression.spel.SpelException; import org.springframework.expression.spel.ExpressionState; -public class OperatorNot extends SpelNode { // Not is a unary operator so do not extend BinaryOperator +public class OperatorNot extends SpelNodeImpl { // Not is a unary operator so do not extend BinaryOperator public OperatorNot(Token payload) { super(payload); } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { try { - boolean value = state.toBoolean(getChild(0).getValue(state)); + boolean value = state.toBoolean(getChild(0).getValueInternal(state)); return !value; } catch (SpelException see) { see.setPosition(getChild(0).getCharPositionInLine()); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorOr.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorOr.java index ecd6df2de51..fc30fa94f9e 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorOr.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorOr.java @@ -37,11 +37,11 @@ public class OperatorOr extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { boolean leftValue; boolean rightValue; try { - leftValue = state.toBoolean(getLeftOperand().getValue(state)); + leftValue = state.toBoolean(getLeftOperand().getValueInternal(state)); } catch (SpelException see) { see.setPosition(getLeftOperand().getCharPositionInLine()); throw see; @@ -51,7 +51,7 @@ public class OperatorOr extends Operator { return true; // no need to evaluate right operand try { - rightValue = state.toBoolean(getRightOperand().getValue(state)); + rightValue = state.toBoolean(getRightOperand().getValueInternal(state)); } catch (SpelException see) { see.setPosition(getRightOperand().getCharPositionInLine()); throw see; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorPlus.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorPlus.java index 2863e7b7c4d..87a50914fd4 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorPlus.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/OperatorPlus.java @@ -27,18 +27,18 @@ public class OperatorPlus extends Operator { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { - SpelNode leftOp = getLeftOperand(); - SpelNode rightOp = getRightOperand(); + public Object getValueInternal(ExpressionState state) throws EvaluationException { + SpelNodeImpl leftOp = getLeftOperand(); + SpelNodeImpl rightOp = getRightOperand(); if (rightOp == null) { // If only one operand, then this is unary plus - Object operandOne = leftOp.getValue(state); + Object operandOne = leftOp.getValueInternal(state); if (operandOne instanceof Number) { return new Integer(((Number) operandOne).intValue()); } return state.operate(Operation.ADD, operandOne, null); } else { - Object operandOne = leftOp.getValue(state); - Object operandTwo = rightOp.getValue(state); + Object operandOne = leftOp.getValueInternal(state); + Object operandTwo = rightOp.getValueInternal(state); if (operandOne instanceof Number && operandTwo instanceof Number) { Number op1 = (Number) operandOne; Number op2 = (Number) operandTwo; diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Placeholder.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Placeholder.java index d6929931b50..a03347ed3f0 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Placeholder.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Placeholder.java @@ -27,14 +27,14 @@ import org.springframework.expression.spel.ExpressionState; * @author Andy Clement * */ -public class Placeholder extends SpelNode { +public class Placeholder extends SpelNodeImpl { public Placeholder(Token payload) { super(payload); } @Override - public String getValue(ExpressionState state) throws SpelException { + public String getValueInternal(ExpressionState state) throws SpelException { throw new SpelException(getCharPositionInLine(), SpelMessages.PLACEHOLDER_SHOULD_NEVER_BE_EVALUATED); } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java index 83a0c906176..ef7d8a74179 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Projection.java @@ -35,14 +35,14 @@ import org.springframework.expression.spel.internal.KeyValuePair; * @author Andy Clement * */ -public class Projection extends SpelNode { +public class Projection extends SpelNodeImpl { public Projection(Token payload) { super(payload); } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Object operand = state.getActiveContextObject(); // When the input is a map, we push a special context object on the stack @@ -56,7 +56,7 @@ public class Projection extends SpelNode { for (Object k : mapdata.keySet()) { try { state.pushActiveContextObject(new KeyValuePair(k, mapdata.get(k))); - result.add(getChild(0).getValue(state)); + result.add(getChild(0).getValueInternal(state)); } finally { state.popActiveContextObject(); } @@ -71,7 +71,7 @@ public class Projection extends SpelNode { try { state.pushActiveContextObject(element); state.enterScope("index", idx); - result.add(getChild(0).getValue(state)); + result.add(getChild(0).getValueInternal(state)); } finally { state.exitScope(); state.popActiveContextObject(); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/PropertyOrFieldReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/PropertyOrFieldReference.java index 7e99f0e987a..3f415be72ca 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/PropertyOrFieldReference.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/PropertyOrFieldReference.java @@ -35,7 +35,7 @@ import org.springframework.expression.spel.internal.Utils; * * @author Andy Clement */ -public class PropertyOrFieldReference extends SpelNode { +public class PropertyOrFieldReference extends SpelNodeImpl { public static boolean useCaching = true; @@ -49,7 +49,7 @@ public class PropertyOrFieldReference extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws SpelException { + public Object getValueInternal(ExpressionState state) throws SpelException { return readProperty(state, name); } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/QualifiedIdentifier.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/QualifiedIdentifier.java index e5a0ce56f49..19cbba945e0 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/QualifiedIdentifier.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/QualifiedIdentifier.java @@ -27,7 +27,7 @@ import org.springframework.expression.spel.ExpressionState; * @author Andy Clement * */ -public class QualifiedIdentifier extends SpelNode { +public class QualifiedIdentifier extends SpelNodeImpl { private String value; @@ -37,14 +37,14 @@ public class QualifiedIdentifier extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { // Cache the concatenation of child identifiers if (value == null) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < getChildCount(); i++) { if (i > 0) sb.append("."); - sb.append(getChild(i).getValue(state)); + sb.append(getChild(i).getValueInternal(state)); } value = sb.toString(); } diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java index e9ac8cabe2e..e431eaa8d98 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Selection.java @@ -36,7 +36,7 @@ import org.springframework.expression.spel.internal.KeyValuePair; * * @author Andy Clement */ -public class Selection extends SpelNode { +public class Selection extends SpelNodeImpl { public final static int ALL = 0; // ?{} public final static int FIRST = 1; // ^{} @@ -50,9 +50,9 @@ public class Selection extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Object operand = state.getActiveContextObject(); - SpelNode selectionCriteria = getChild(0); + SpelNodeImpl selectionCriteria = getChild(0); if (operand instanceof Map) { Map mapdata = (Map) operand; List result = new ArrayList(); @@ -60,7 +60,7 @@ public class Selection extends SpelNode { try { Object kvpair = new KeyValuePair(k, mapdata.get(k)); state.pushActiveContextObject(kvpair); - Object o = selectionCriteria.getValue(state); + Object o = selectionCriteria.getValueInternal(state); if (o instanceof Boolean) { if (((Boolean) o).booleanValue() == true) { if (variant == FIRST) @@ -91,7 +91,7 @@ public class Selection extends SpelNode { try { state.pushActiveContextObject(element); state.enterScope("index", idx); - Object o = selectionCriteria.getValue(state); + Object o = selectionCriteria.getValueInternal(state); if (o instanceof Boolean) { if (((Boolean) o).booleanValue() == true) { if (variant == FIRST) diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Ternary.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Ternary.java index 0105e1e7ce4..bc9c4f4cefb 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Ternary.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/Ternary.java @@ -25,7 +25,7 @@ import org.springframework.expression.spel.SpelException; * * @author Andy Clement */ -public class Ternary extends SpelNode { +public class Ternary extends SpelNodeImpl { public Ternary(Token payload) { super(payload); @@ -39,13 +39,13 @@ public class Ternary extends SpelNode { * executing the chosen alternative */ @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { Boolean b = (Boolean) getChild(0).getValue(state, Boolean.class); try { if (b) { - return getChild(1).getValue(state); + return getChild(1).getValueInternal(state); } else { - return getChild(2).getValue(state); + return getChild(2).getValueInternal(state); } } catch (SpelException ex) { ex.setPosition(getChild(0).getCharPositionInLine()); diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java index b4a2248ca5d..6877e970eeb 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java @@ -27,16 +27,16 @@ import org.springframework.expression.spel.internal.TypeCode; * @author Andy Clement * */ -public class TypeReference extends SpelNode { +public class TypeReference extends SpelNodeImpl { public TypeReference(Token payload) { super(payload); } @Override - public Object getValue(ExpressionState state) throws EvaluationException { + public Object getValueInternal(ExpressionState state) throws EvaluationException { // TODO possible optimization here if we cache the discovered type reference, but can we do that? - String typename = (String) getChild(0).getValue(state); + String typename = (String) getChild(0).getValueInternal(state); if (typename.indexOf(".") == -1 && Character.isLowerCase(typename.charAt(0))) { TypeCode tc = TypeCode.forName(typename); if (tc != TypeCode.OBJECT) { diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/VariableReference.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/VariableReference.java index 5acb96034c8..6d9c12a833c 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/VariableReference.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/VariableReference.java @@ -26,7 +26,7 @@ import org.springframework.expression.spel.ExpressionState; * @author Andy Clement * */ -public class VariableReference extends SpelNode { +public class VariableReference extends SpelNodeImpl { // Well known variables: private final static String THIS = "this"; // currently active context object @@ -40,7 +40,7 @@ public class VariableReference extends SpelNode { } @Override - public Object getValue(ExpressionState state) throws SpelException { + public Object getValueInternal(ExpressionState state) throws SpelException { if (name.equals(THIS)) return state.getActiveContextObject(); if (name.equals(ROOT)) diff --git a/org.springframework.expression/src/main/java/org/springframework/expression/spel/generated/SpringExpressionsParser.java b/org.springframework.expression/src/main/java/org/springframework/expression/spel/generated/SpringExpressionsParser.java index 33cc0da81ce..d69bdde056b 100644 --- a/org.springframework.expression/src/main/java/org/springframework/expression/spel/generated/SpringExpressionsParser.java +++ b/org.springframework.expression/src/main/java/org/springframework/expression/spel/generated/SpringExpressionsParser.java @@ -1,14 +1,22 @@ // $ANTLR 3.0.1 /Users/aclement/el2/spring-framework/trunk/org.springframework.expression/src/main/java/org/springframework/expression/spel/generated/SpringExpressions.g 2008-09-16 19:06:07 package org.springframework.expression.spel.generated; -import org.antlr.runtime.*; -import java.util.Stack; -import java.util.List; -import java.util.ArrayList; -import java.util.Map; import java.util.HashMap; +import java.util.Stack; -import org.antlr.runtime.tree.*; +import org.antlr.runtime.BitSet; +import org.antlr.runtime.EarlyExitException; +import org.antlr.runtime.MismatchedSetException; +import org.antlr.runtime.NoViableAltException; +import org.antlr.runtime.Parser; +import org.antlr.runtime.ParserRuleReturnScope; +import org.antlr.runtime.RecognitionException; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenStream; +import org.antlr.runtime.tree.CommonTreeAdaptor; +import org.antlr.runtime.tree.RewriteRuleSubtreeStream; +import org.antlr.runtime.tree.RewriteRuleTokenStream; +import org.antlr.runtime.tree.TreeAdaptor; public class SpringExpressionsParser extends Parser { public static final String[] tokenNames = new String[] { diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/ConstructorInvocationTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/ConstructorInvocationTests.java index 4290678d299..3a8dc2f5fd0 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/ConstructorInvocationTests.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/ConstructorInvocationTests.java @@ -24,6 +24,8 @@ import org.springframework.expression.spel.standard.StandardEvaluationContext; */ public class ConstructorInvocationTests extends ExpressionTestCase { + // Some tests commented out as language support has been removed for now + // public void testPrimitiveTypeArrayConstructors() { // evaluate("new int[]{1,2,3,4}.count()", 4, Integer.class); // evaluate("new boolean[]{true,false,true}.count()", 3, Integer.class); @@ -46,11 +48,6 @@ public class ConstructorInvocationTests extends ExpressionTestCase { // evaluate("new byte[]{1,2,3,4}[0]", (byte) 1, Byte.class); // } - public void testTypeConstructors() { - evaluate("new String('hello world')", "hello world", String.class); - // evaluate("new String(new char[]{'h','e','l','l','o'})", "hello", String.class); - } - // public void testErrorCases() { // evaluateAndCheckError("new char[7]{'a','c','d','e'}", SpelMessages.INITIALIZER_LENGTH_INCORRECT); // evaluateAndCheckError("new char[3]{'a','c','d','e'}", SpelMessages.INITIALIZER_LENGTH_INCORRECT); @@ -75,6 +72,11 @@ public class ConstructorInvocationTests extends ExpressionTestCase { // new String[3][4].getClass()); // } + public void testTypeConstructors() { + evaluate("new String('hello world')", "hello world", String.class); + // evaluate("new String(new char[]{'h','e','l','l','o'})", "hello", String.class); + } + /* * These tests are attempting to call constructors where we need to widen or convert the argument in order to * satisfy a suitable constructor. diff --git a/org.springframework.expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java b/org.springframework.expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java index 833c3bbc18b..34783e664b9 100644 --- a/org.springframework.expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java +++ b/org.springframework.expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java @@ -18,6 +18,8 @@ package org.springframework.expression.spel; /** * Tests the evaluation of real expressions in a real context. * + * Node: Some tests commented out as language support has been removed + * * @author Andy Clement */ public class EvaluationTests extends ExpressionTestCase {