jsf/plugins/org.eclipse.jst.pagedesigner.jsp.core/src/org/eclipse/jst/pagedesigner/jsp/core/el/JSFELParserHelper.java - jsf/webtools.jsf - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006 Sybase, Inc. and others.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Sybase, Inc. - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.pagedesigner.jsp.core.el;

 import java.io.StringReader;

 import org.apache.commons.el.Expression;
 import org.apache.commons.el.ExpressionString;
 import org.apache.commons.el.parser.ELParser;
 import org.apache.commons.el.parser.ParseException;

 /**
  * Utility class to implement support functionality to "morph" JSP EL into JSF
  * EL
  *
  * @author mengbo
  * @version 1.5
  */
 public final class JSFELParserHelper {
 	/**
 	 * an EL left brace
 	 */
 	public static String JSF_EL_LEFT_BRACE = "#{"; //$NON-NLS-1$

 	/**
 	 * an EL right brace
 	 */
 	public static String JSF_EL_RIGHT_BRACE = "}"; //$NON-NLS-1$

 	private JSFELParserHelper() {
 		// util class, do not instantiate
 	}

 	/**
 	 * Gets the parsed form of the given expression string. Returns either an
 	 * Expression or ExpressionString.
 	 * @param expressionString
 	 * @return the result of parsing 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)) {
 				return null;
 			}

 			return expression;
 		} catch (ParseException e) {

 			// String msg = "Invalid expression: '" + expressionString + "'";
 			// log.debug(msg, e);
 			// throw new ReferenceSyntaxException(msg, e);
 		}
 		return null;
 	}

 	/**
 	 * @param expressionString
 	 * @return true if the expression is 'valid'
 	 */
 	public static boolean isValidEL(String expressionString) {
 		if (expressionString == null || expressionString.length() == 0) {
 			return false;
 		}

 		return expressionString.startsWith(JSF_EL_LEFT_BRACE)
 				&& expressionString.endsWith(JSF_EL_RIGHT_BRACE);
 	}

 	/**
 	 * @param expressionString
 	 * @return expressionString with the left and right braces removed
 	 * or the original string if isValidEL(expression) == false
 	 */
 	public static String trimELBrace(String expressionString) {
 		if (!isValidEL(expressionString)) {
 			return expressionString;
 		}
 		String trimedExpression = null;

 		trimedExpression = expressionString.substring(JSF_EL_LEFT_BRACE
 				.length(), expressionString.length()
 				- JSF_EL_RIGHT_BRACE.length());

 		return trimedExpression;
 	}

 	/**
 	 * Convert ValueBinding syntax #{ } to JSP EL syntax ${ }
 	 *
 	 * @param expressionString
 	 *            <code>ValueBinding</code> reference expression
 	 *
 	 * @return JSP EL compatible expression
 	 */
 	public 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("${'${'}"); //$NON-NLS-1$
 					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("${"); //$NON-NLS-1$
 					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 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 IllegalStateException(
 						"Missing closing brace. Expression: '" //$NON-NLS-1$
 								+ expressionString + "'"); //$NON-NLS-1$
 			}

 			int indexofClosingBrace = expressionString.indexOf('}', i);
 			i = minIndex(indexofClosingBrace, findQuote(expressionString, i));

 			if (i < 0) {
 				// No delimiter found
 				throw new IllegalStateException(
 						"Missing closing brace. Expression: '" //$NON-NLS-1$
 								+ expressionString + "'"); //$NON-NLS-1$
 			}

 			// 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 IllegalStateException(
 							"Missing closing quote. Expression: '" //$NON-NLS-1$
 									+ expressionString + "'"); //$NON-NLS-1$
 				}
 			} 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;
 	}

 	/**
 	 * Returns the minimum index >= 0, if any
 	 *
 	 * <p>
 	 * Use to find the first of two characters in a string:<br>
 	 * <code>minIndex(s.indexOf('/'), indexOf('\'))</code>
 	 * </p>
 	 * @param a
 	 * @param b
 	 * @return the minimum index >= 0, if any
 	 *
 	 */
 	public static int minIndex(int a, int b) {
 		return (a < 0) ? b : (b < 0) ? a : (a < b) ? a : b;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2006 Sybase, Inc. and others.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Sybase, Inc. - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.pagedesigner.jsp.core.el;

	import java.io.StringReader;

	import org.apache.commons.el.Expression;
	import org.apache.commons.el.ExpressionString;
	import org.apache.commons.el.parser.ELParser;
	import org.apache.commons.el.parser.ParseException;

	/**
	* Utility class to implement support functionality to "morph" JSP EL into JSF
	* EL
	*
	* @author mengbo
	* @version 1.5
	*/
	public final class JSFELParserHelper {
	/**
	* an EL left brace
	*/
	public static String JSF_EL_LEFT_BRACE = "#{"; //$NON-NLS-1$

	/**
	* an EL right brace
	*/
	public static String JSF_EL_RIGHT_BRACE = "}"; //$NON-NLS-1$

	private JSFELParserHelper() {
	// util class, do not instantiate
	}

	/**
	* Gets the parsed form of the given expression string. Returns either an
	* Expression or ExpressionString.
	* @param expressionString
	* @return the result of parsing 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)) {
	return null;
	}

	return expression;
	} catch (ParseException e) {

	// String msg = "Invalid expression: '" + expressionString + "'";
	// log.debug(msg, e);
	// throw new ReferenceSyntaxException(msg, e);
	}
	return null;
	}

	/**
	* @param expressionString
	* @return true if the expression is 'valid'
	*/
	public static boolean isValidEL(String expressionString) {
	if (expressionString == null \|\| expressionString.length() == 0) {
	return false;
	}

	return expressionString.startsWith(JSF_EL_LEFT_BRACE)
	&& expressionString.endsWith(JSF_EL_RIGHT_BRACE);
	}

	/**
	* @param expressionString
	* @return expressionString with the left and right braces removed
	* or the original string if isValidEL(expression) == false
	*/
	public static String trimELBrace(String expressionString) {
	if (!isValidEL(expressionString)) {
	return expressionString;
	}
	String trimedExpression = null;

	trimedExpression = expressionString.substring(JSF_EL_LEFT_BRACE
	.length(), expressionString.length()
	- JSF_EL_RIGHT_BRACE.length());

	return trimedExpression;
	}

	/**
	* Convert ValueBinding syntax #{ } to JSP EL syntax ${ }
	*
	* @param expressionString
	* <code>ValueBinding</code> reference expression
	*
	* @return JSP EL compatible expression
	*/
	public 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("${'${'}"); //$NON-NLS-1$
	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("${"); //$NON-NLS-1$
	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 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 IllegalStateException(
	"Missing closing brace. Expression: '" //$NON-NLS-1$
	+ expressionString + "'"); //$NON-NLS-1$
	}

	int indexofClosingBrace = expressionString.indexOf('}', i);
	i = minIndex(indexofClosingBrace, findQuote(expressionString, i));

	if (i < 0) {
	// No delimiter found
	throw new IllegalStateException(
	"Missing closing brace. Expression: '" //$NON-NLS-1$
	+ expressionString + "'"); //$NON-NLS-1$
	}

	// 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 IllegalStateException(
	"Missing closing quote. Expression: '" //$NON-NLS-1$
	+ expressionString + "'"); //$NON-NLS-1$
	}
	} 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;
	}

	/**
	* Returns the minimum index >= 0, if any
	*
	* <p>
	* Use to find the first of two characters in a string:<br>
	* <code>minIndex(s.indexOf('/'), indexOf('\'))</code>
	* </p>
	* @param a
	* @param b
	* @return the minimum index >= 0, if any
	*
	*/
	public static int minIndex(int a, int b) {
	return (a < 0) ? b : (b < 0) ? a : (a < b) ? a : b;
	}
	}