// $ANTLR 2.7.5 (20050128): "ValidWhenParser.g" -> "ValidWhenParser.java"$
/*
* $Header: /cvs/springmodules/projects/validation/src/java/org/springmodules/validation/commons/validwhen/ValidWhenParser.java,v 1.3 2006/10/27 01:59:59 hueboness Exp $
* $Revision: 1.3 $
* $Date: 2006/10/27 01:59:59 $
*
* Copyright 2003-2004 The Apache Software Foundation.
*
* Licensed 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.springmodules.validation.commons.validwhen;
import java.math.BigDecimal;
import java.util.Stack;
import antlr.*;
import antlr.collections.impl.BitSet;
import org.apache.commons.validator.util.ValidatorUtils;
public class ValidWhenParser extends antlr.LLkParser implements ValidWhenParserTokenTypes {
Stack argStack = new Stack();
Object form;
int index;
String value;
public void setForm(Object f) {
form = f;
}
;
public void setIndex(int i) {
index = i;
}
;
public void setValue(String v) {
value = v;
}
;
public boolean getResult() {
return ((Boolean) argStack.peek()).booleanValue();
}
private final int LESS_EQUAL = 0;
private final int LESS_THAN = 1;
private final int EQUAL = 2;
private final int GREATER_THAN = 3;
private final int GREATER_EQUAL = 4;
private final int NOT_EQUAL = 5;
private final int AND = 6;
private final int OR = 7;
private boolean evaluateComparison(Object v1, Object compare, Object v2) {
if ((v1 == null) || (v2 == null)) {
if (String.class.isInstance(v1)) {
if (((String) v1).length() == 0) {
v1 = null;
}
}
if (String.class.isInstance(v2)) {
if (((String) v2).length() == 0) {
v2 = null;
}
}
switch (((Integer) compare).intValue()) {
case LESS_EQUAL:
case GREATER_THAN:
case LESS_THAN:
case GREATER_EQUAL:
return false;
case EQUAL:
return (v1 == v2);
case NOT_EQUAL:
return (v1 != v2);
}
}
boolean numberCompare = true;
if ((BigDecimal.class.isInstance(v1) || String.class.isInstance(v1)) &&
(BigDecimal.class.isInstance(v2) || String.class.isInstance(v2))) {
numberCompare = true;
} else {
numberCompare = false;
}
if (numberCompare) {
try {
BigDecimal number1, number2;
if (BigDecimal.class.isInstance(v1)) {
number1 = (BigDecimal) v1;
} else {
number1 = new BigDecimal((String) v1);
}
if (BigDecimal.class.isInstance(v2)) {
number2 = (BigDecimal) v2;
} else {
number2 = new BigDecimal((String) v2);
}
int compareResult = number1.compareTo(number2);
switch (((Integer) compare).intValue()) {
case LESS_EQUAL:
return (compareResult <= 0);
case LESS_THAN:
return (compareResult < 0);
case EQUAL:
return (compareResult == 0);
case GREATER_THAN:
return (compareResult > 0);
case GREATER_EQUAL:
return (compareResult >= 0);
case NOT_EQUAL:
return (compareResult != 0);
}
} catch (NumberFormatException ex) {
}
;
}
String string1 = String.valueOf(v1);
String string2 = String.valueOf(v2);
int res = string1.compareTo(string2);
switch (((Integer) compare).intValue()) {
case LESS_EQUAL:
return (res <= 0);
case LESS_THAN:
return (res < 0);
case EQUAL:
return (res == 0);
case GREATER_THAN:
return (res > 0);
case GREATER_EQUAL:
return (res >= 0);
case NOT_EQUAL:
return (res != 0);
}
return true;
}
protected ValidWhenParser(TokenBuffer tokenBuf, int k) {
super(tokenBuf, k);
tokenNames = _tokenNames;
}
public ValidWhenParser(TokenBuffer tokenBuf) {
this(tokenBuf, 6);
}
protected ValidWhenParser(TokenStream lexer, int k) {
super(lexer, k);
tokenNames = _tokenNames;
}
public ValidWhenParser(TokenStream lexer) {
this(lexer, 6);
}
public ValidWhenParser(ParserSharedInputState state) {
super(state, 6);
tokenNames = _tokenNames;
}
public final void number() throws RecognitionException, TokenStreamException {
Token d = null;
Token h = null;
switch (LA(1)) {
case DECIMAL_LITERAL: {
d = LT(1);
match(DECIMAL_LITERAL);
argStack.push(new BigDecimal(d.getText()));
break;
}
case HEX_LITERAL: {
h = LT(1);
match(HEX_LITERAL);
argStack.push(new BigDecimal(Integer.decode(h.getText()).toString()));
break;
}
default: {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void string() throws RecognitionException, TokenStreamException {
Token str = null;
str = LT(1);
match(STRING_LITERAL);
argStack.push(str.getText().substring(1, str.getText().length() - 1));
}
public final void identifier() throws RecognitionException, TokenStreamException {
Token str = null;
str = LT(1);
match(IDENTIFIER);
argStack.push(str.getText());
}
public final void field() throws RecognitionException, TokenStreamException {
if ((LA(1) == IDENTIFIER) && (LA(2) == LBRACKET) && (LA(3) == RBRACKET) && (LA(4) == IDENTIFIER)) {
identifier();
match(LBRACKET);
match(RBRACKET);
identifier();
Object i2 = argStack.pop();
Object i1 = argStack.pop();
argStack.push(ValidatorUtils.getValueAsString(form, i1 + "[" + index + "]" + i2));
} else
if ((LA(1) == IDENTIFIER) && (LA(2) == LBRACKET) && (LA(3) == DECIMAL_LITERAL || LA(3) == HEX_LITERAL) && (LA(4) == RBRACKET) && (LA(5) == IDENTIFIER))
{
identifier();
match(LBRACKET);
number();
match(RBRACKET);
identifier();
Object i5 = argStack.pop();
Object i4 = argStack.pop();
Object i3 = argStack.pop();
argStack.push(ValidatorUtils.getValueAsString(form, i3 + "[" + i4 + "]" + i5));
} else
if ((LA(1) == IDENTIFIER) && (LA(2) == LBRACKET) && (LA(3) == DECIMAL_LITERAL || LA(3) == HEX_LITERAL) && (LA(4) == RBRACKET) && (LA(5) == LBRACKET))
{
identifier();
match(LBRACKET);
number();
match(RBRACKET);
match(LBRACKET);
Object i7 = argStack.pop();
Object i6 = argStack.pop();
argStack.push(ValidatorUtils.getValueAsString(form, i6 + "[" + i7 + "]"));
} else if ((LA(1) == IDENTIFIER) && (LA(2) == LBRACKET) && (LA(3) == RBRACKET) && (_tokenSet_0.member(LA(4)))) {
identifier();
match(LBRACKET);
match(RBRACKET);
Object i8 = argStack.pop();
argStack.push(ValidatorUtils.getValueAsString(form, i8 + "[" + index + "]"));
} else if ((LA(1) == IDENTIFIER) && (_tokenSet_0.member(LA(2)))) {
identifier();
Object i9 = argStack.pop();
argStack.push(ValidatorUtils.getValueAsString(form, (String) i9));
} else {
throw new NoViableAltException(LT(1), getFilename());
}
}
public final void literal() throws RecognitionException, TokenStreamException {
switch (LA(1)) {
case DECIMAL_LITERAL:
case HEX_LITERAL: {
number();
break;
}
case STRING_LITERAL: {
string();
break;
}
case LITERAL_null: {
match(LITERAL_null);
argStack.push(null);
break;
}
case THIS: {
match(THIS);
argStack.push(value);
break;
}
default: {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void value() throws RecognitionException, TokenStreamException {
switch (LA(1)) {
case IDENTIFIER: {
field();
break;
}
case DECIMAL_LITERAL:
case HEX_LITERAL:
case STRING_LITERAL:
case LITERAL_null:
case THIS: {
literal();
break;
}
default: {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void expression() throws RecognitionException, TokenStreamException {
expr();
match(Token.EOF_TYPE);
}
public final void expr() throws RecognitionException, TokenStreamException {
if ((LA(1) == LPAREN) && (_tokenSet_1.member(LA(2)))) {
match(LPAREN);
comparisonExpression();
match(RPAREN);
} else if ((LA(1) == LPAREN) && (LA(2) == LPAREN)) {
match(LPAREN);
joinedExpression();
match(RPAREN);
} else {
throw new NoViableAltException(LT(1), getFilename());
}
}
public final void comparisonExpression() throws RecognitionException, TokenStreamException {
value();
comparison();
value();
Object v2 = argStack.pop();
Object comp = argStack.pop();
Object v1 = argStack.pop();
argStack.push(new Boolean(evaluateComparison(v1, comp, v2)));
}
public final void joinedExpression() throws RecognitionException, TokenStreamException {
expr();
join();
expr();
Boolean v1 = (Boolean) argStack.pop();
Integer join = (Integer) argStack.pop();
Boolean v2 = (Boolean) argStack.pop();
if (join.intValue() == AND) {
argStack.push(new Boolean(v1.booleanValue() && v2.booleanValue()));
} else {
argStack.push(new Boolean(v1.booleanValue() || v2.booleanValue()));
}
}
public final void join() throws RecognitionException, TokenStreamException {
switch (LA(1)) {
case ANDSIGN: {
match(ANDSIGN);
argStack.push(new Integer(AND));
break;
}
case ORSIGN: {
match(ORSIGN);
argStack.push(new Integer(OR));
break;
}
default: {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public final void comparison() throws RecognitionException, TokenStreamException {
switch (LA(1)) {
case EQUALSIGN: {
match(EQUALSIGN);
argStack.push(new Integer(EQUAL));
break;
}
case GREATERTHANSIGN: {
match(GREATERTHANSIGN);
argStack.push(new Integer(GREATER_THAN));
break;
}
case GREATEREQUALSIGN: {
match(GREATEREQUALSIGN);
argStack.push(new Integer(GREATER_EQUAL));
break;
}
case LESSTHANSIGN: {
match(LESSTHANSIGN);
argStack.push(new Integer(LESS_THAN));
break;
}
case LESSEQUALSIGN: {
match(LESSEQUALSIGN);
argStack.push(new Integer(LESS_EQUAL));
break;
}
case NOTEQUALSIGN: {
match(NOTEQUALSIGN);
argStack.push(new Integer(NOT_EQUAL));
break;
}
default: {
throw new NoViableAltException(LT(1), getFilename());
}
}
}
public static final String[] _tokenNames = {
"<0>",
"EOF",
"<2>",
"NULL_TREE_LOOKAHEAD",
"DECIMAL_LITERAL",
"HEX_LITERAL",
"STRING_LITERAL",
"IDENTIFIER",
"LBRACKET",
"RBRACKET",
"\"null\"",
"THIS",
"LPAREN",
"RPAREN",
"\"and\"",
"\"or\"",
"EQUALSIGN",
"GREATERTHANSIGN",
"GREATEREQUALSIGN",
"LESSTHANSIGN",
"LESSEQUALSIGN",
"NOTEQUALSIGN",
"WS"
};
private static final long[] mk_tokenSet_0() {
long[] data = {4136960L, 0L};
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = {3312L, 0L};
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
}