/*
* 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.
*/
package org.apache.myfaces.el;
import java.io.StringReader;
import java.util.List;
import javax.faces.application.Application;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.el.EvaluationException;
import javax.faces.el.ReferenceSyntaxException;
import javax.servlet.jsp.el.ELException;
import javax.servlet.jsp.el.FunctionMapper;
import javax.servlet.jsp.el.VariableResolver;
import org.apache.myfaces.shared_impl.util.StringUtils;
import org.apache.commons.el.ArraySuffix;
import org.apache.commons.el.BinaryOperatorExpression;
import org.apache.commons.el.Coercions;
import org.apache.commons.el.ComplexValue;
import org.apache.commons.el.ConditionalExpression;
import org.apache.commons.el.Expression;
import org.apache.commons.el.ExpressionString;
import org.apache.commons.el.FunctionInvocation;
import org.apache.commons.el.Literal;
import org.apache.commons.el.Logger;
import org.apache.commons.el.NamedValue;
import org.apache.commons.el.PropertySuffix;
import org.apache.commons.el.UnaryOperatorExpression;
import org.apache.commons.el.ValueSuffix;
import org.apache.commons.el.parser.ELParser;
import org.apache.commons.el.parser.ParseException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Utility class to implement support functionality to "morph" JSP EL into JSF
* EL
*
* @author Anton Koinov (latest modification by $Author: skitching $)
* @version $Revision: 673803 $ $Date: 2008-07-03 16:07:46 -0500 (Thu, 03 Jul 2008) $
*/
public class ELParserHelper
{
static final Log log = LogFactory.getLog(ELParserHelper.class);
public static final Logger LOGGER = new Logger(System.out);
private ELParserHelper()
{
// util class, do not instantiate
}
/**
* Gets the parsed form of the given expression string. Returns either an
* Expression or ExpressionString.
*/
public static Object parseExpression(String expressionString)
{
expressionString = toJspElExpression(expressionString);
ELParser parser = new ELParser(new StringReader(expressionString));
try
{
Object expression = parser.ExpressionString();
if (!(expression instanceof Expression)
&& !(expression instanceof ExpressionString))
{
throw new ReferenceSyntaxException("Invalid expression: '"
+ expressionString
+ "'. Parsed Expression of unexpected type "
+ expression.getClass().getName());
}
replaceSuffixes(expression);
return expression;
}
catch (ParseException e)
{
String msg = "Invalid expression: '" + expressionString + "'";
throw new ReferenceSyntaxException(msg, e);
}
}
/**
* Convert ValueBinding syntax #{ } to JSP EL syntax ${ }
*
* @param expressionString <code>ValueBinding</code> reference expression
*
* @return JSP EL compatible expression
*/
static String toJspElExpression(String expressionString)
{
StringBuffer sb = new StringBuffer(expressionString.length());
int remainsPos = 0;
for (int posOpenBrace = expressionString.indexOf('{'); posOpenBrace >= 0;
posOpenBrace = expressionString.indexOf('{', remainsPos))
{
if (posOpenBrace > 0)
{
if( posOpenBrace-1 > remainsPos )
sb.append(expressionString.substring(remainsPos, posOpenBrace - 1));
if (expressionString.charAt(posOpenBrace - 1) == '$')
{
sb.append("${'${'}");
remainsPos = posOpenBrace+1;
continue;
}
else if (expressionString.charAt(posOpenBrace - 1) == '#')
{
// // TODO: should use \\ as escape for \ always, not just when before #{
// // allow use of '\' as escape symbol for #{ (for compatibility with Sun's extended implementation)
// if (isEscaped(expressionString, posOpenBrace - 1))
// {
// escapes: {
// for (int i = sb.length() - 1; i >= 0; i--)
// {
// if (sb.charAt(i) != '\\')
// {
// sb.setLength(
// sb.length() - (sb.length() - i) / 2);
// break escapes;
// }
// }
// sb.setLength(sb.length() / 2);
// }
// sb.append("#{");
// }
// else
// {
sb.append("${");
int posCloseBrace = indexOfMatchingClosingBrace(expressionString, posOpenBrace);
sb.append(expressionString.substring(posOpenBrace + 1, posCloseBrace + 1));
remainsPos = posCloseBrace + 1;
continue;
// }
}else{
if( posOpenBrace > remainsPos )
sb.append( expressionString.charAt(posOpenBrace - 1) );
}
}
// Standalone brace
sb.append('{');
remainsPos = posOpenBrace + 1;
}
sb.append(expressionString.substring(remainsPos));
// Create a new String to shrink mem size since we are caching
return new String(sb.toString());
}
private static int findQuote(String expressionString, int start)
{
int indexofSingleQuote = expressionString.indexOf('\'', start);
int indexofDoubleQuote = expressionString.indexOf('"', start);
return StringUtils.minIndex(indexofSingleQuote, indexofDoubleQuote);
}
/**
* Return the index of the matching closing brace, skipping over quoted text
*
* @param expressionString string to search
* @param indexofOpeningBrace the location of opening brace to match
*
* @return the index of the matching closing brace
*
* @throws ReferenceSyntaxException if matching brace cannot be found
*/
private static int indexOfMatchingClosingBrace(String expressionString,
int indexofOpeningBrace)
{
int len = expressionString.length();
int i = indexofOpeningBrace + 1;
// Loop through quoted strings
for (;;)
{
if (i >= len)
{
throw new ReferenceSyntaxException(
"Missing closing brace. Expression: '" + expressionString
+ "'");
}
int indexofClosingBrace = expressionString.indexOf('}', i);
i = StringUtils.minIndex(indexofClosingBrace, findQuote(
expressionString, i));
if (i < 0)
{
// No delimiter found
throw new ReferenceSyntaxException(
"Missing closing brace. Expression: '" + expressionString
+ "'");
}
// 1. If quoted literal, find closing quote
if (i != indexofClosingBrace)
{
i = indexOfMatchingClosingQuote(expressionString, i) + 1;
if (i == 0)
{
// Note: if no match, i==0 because -1 + 1 = 0
throw new ReferenceSyntaxException(
"Missing closing quote. Expression: '"
+ expressionString + "'");
}
}
else
{
// Closing brace
return i;
}
}
}
/**
* Returns the index of the matching closing quote, skipping over escaped
* quotes
*
* @param expressionString string to scan
* @param indexOfOpeningQuote start from this position in the string
* @return -1 if no match, the index of closing quote otherwise
*/
private static int indexOfMatchingClosingQuote(String expressionString,
int indexOfOpeningQuote)
{
char quote = expressionString.charAt(indexOfOpeningQuote);
for (int i = expressionString.indexOf(quote, indexOfOpeningQuote + 1);
i >= 0; i = expressionString.indexOf(quote, i + 1))
{
if (!isEscaped(expressionString, i))
{
return i;
}
}
// No matching quote found
return -1;
}
private static boolean isEscaped(String expressionString, int i)
{
int escapeCharCount = 0;
while ((--i >= 0) && (expressionString.charAt(i) == '\\'))
{
escapeCharCount++;
}
return (escapeCharCount % 2) != 0;
}
/**
* Replaces all <code>ValueSuffix</code>es with custom implementation
* ValueSuffexes that use JSF <code>PropertyResolver</code> insted of JSP
* EL one.
*
* @param expression <code>Expression</code> or
* <code>ExpressionString</code> instance
* @param application <code>Application</code> instance to get
* <code>PropertyResolver</code> from
*/
private static void replaceSuffixes(Object expression)
{
if (expression instanceof Expression)
{
replaceSuffixes((Expression) expression);
}
else if (expression instanceof ExpressionString)
{
replaceSuffixes((ExpressionString) expression);
}
else
{
throw new IllegalStateException(
"Expression element of unknown class: "
+ expression.getClass().getName());
}
}
private static void replaceSuffixes(ExpressionString expressionString)
{
Object[] expressions = expressionString.getElements();
for (int i = 0, len = expressions.length; i < len; i++)
{
Object expression = expressions[i];
if (expression instanceof Expression)
{
replaceSuffixes((Expression) expression);
}
else if (expression instanceof ExpressionString)
{
replaceSuffixes((ExpressionString) expression);
}
else if (!(expression instanceof String))
{
throw new IllegalStateException(
"Expression element of unknown class: "
+ expression.getClass().getName());
}
// ignore Strings
}
}
static void replaceSuffixes(Expression expression)
{
if (expression instanceof BinaryOperatorExpression)
{
BinaryOperatorExpression boe = (BinaryOperatorExpression) expression;
replaceSuffixes(boe.getExpression());
for (int i = 0; i < boe.getExpressions().size(); i++)
{
replaceSuffixes(boe.getExpressions().get(i));
}
}
else if (expression instanceof ComplexValue)
{
replaceSuffixes((ComplexValue) expression);
}
else if (expression instanceof ConditionalExpression)
{
ConditionalExpression conditionalExpression =
(ConditionalExpression) expression;
replaceSuffixes(conditionalExpression.getTrueBranch());
replaceSuffixes(conditionalExpression.getFalseBranch());
}
else if (expression instanceof UnaryOperatorExpression)
{
replaceSuffixes(((UnaryOperatorExpression) expression)
.getExpression());
}
// ignore the remaining expression types
else if (!(expression instanceof FunctionInvocation
|| expression instanceof Literal || expression instanceof NamedValue))
{
throw new IllegalStateException(
"Expression element of unknown class: "
+ expression.getClass().getName());
}
}
private static void replaceSuffixes(ComplexValue complexValue)
{
Application application = FacesContext.getCurrentInstance()
.getApplication();
List suffixes = complexValue.getSuffixes();
for (int i = 0, len = suffixes.size(); i < len; i++)
{
ValueSuffix suffix = (ValueSuffix) suffixes.get(i);
if (suffix instanceof PropertySuffix)
{
if (suffix instanceof MyPropertySuffix)
{
throw new IllegalStateException(
"Suffix is MyPropertySuffix and must not be");
}
suffixes.set(i, new MyPropertySuffix((PropertySuffix) suffix,
application));
}
else if (suffix instanceof ArraySuffix)
{
if (suffix instanceof MyArraySuffix)
{
throw new IllegalStateException(
"Suffix is MyArraySuffix and must not be");
}
suffixes.set(i, new MyArraySuffix((ArraySuffix) suffix,
application));
}
else
{
throw new IllegalStateException("Unknown suffix class: "
+ suffix.getClass().getName());
}
}
}
private static Integer coerceToIntegerWrapper(Object base, Object index)
throws EvaluationException, ELException
{
Integer integer = Coercions.coerceToInteger(index, LOGGER);
if (integer != null)
{
return integer;
}
throw new ReferenceSyntaxException(
"Cannot convert index to int for base " + base.getClass().getName()
+ " and index " + index);
}
/**
* Coerces <code>index</code> to Integer for array types, or returns
* <code>null</code> for non-array types.
*
* @param base Object for the base
* @param index Object for the index
* @return Integer a valid Integer index, or null if not an array type
*
* @throws ELException if exception occurs trying to coerce to Integer
* @throws EvaluationException if base is array type but cannot convert
* index to Integer
*/
public static Integer toIndex(Object base, Object index)
throws ELException, EvaluationException
{
if ((base instanceof List) || (base.getClass().isArray()))
{
return coerceToIntegerWrapper(base, index);
}
if (base instanceof UIComponent)
{
try
{
return coerceToIntegerWrapper(base, index);
}
catch (Throwable t)
{
// treat as simple property
return null;
}
}
// If not an array type
return null;
}
/**
* Override ArraySuffix.evaluate() to use our property resolver
*/
public static class MyArraySuffix extends ArraySuffix
{
private Application _application;
public MyArraySuffix(ArraySuffix arraySuffix, Application application)
{
super(arraySuffix.getIndex());
replaceSuffixes(getIndex());
_application = application;
}
/**
* Evaluates the expression in the given context, operating on the given
* value, using JSF property resolver.
*/
public Object evaluate(Object base, VariableResolver variableResolver,
FunctionMapper functions, Logger logger)
throws ELException
{
// Check for null value
if (base == null)
{
return null;
}
// Evaluate the index
Object indexVal = getIndex().evaluate(variableResolver, functions,
logger);
if (indexVal == null)
{
return null;
}
Integer index = toIndex(base, indexVal);
if (index == null)
{
return _application.getPropertyResolver().getValue(base,
indexVal);
}
else
{
return _application.getPropertyResolver().getValue(base,
index.intValue());
}
}
}
public static class MyPropertySuffix extends PropertySuffix
{
private Application _application;
public MyPropertySuffix(PropertySuffix propertySuffix,
Application application)
{
super(propertySuffix.getName());
_application = application;
}
/**
* Evaluates the expression in the given context, operating on the given
* value, using JSF property resolver.
*/
public Object evaluate(Object base, VariableResolver variableResolver,
FunctionMapper functions, Logger logger)
throws ELException
{
// Check for null value
if (base == null)
{
return null;
}
// Evaluate the index
String indexVal = getName();
if (indexVal == null)
{
return null;
}
Integer index = toIndex(base, indexVal);
if (index == null)
{
return _application.getPropertyResolver().getValue(base,
indexVal);
}
else
{
return _application.getPropertyResolver().getValue(base,
index.intValue());
}
}
}
}