// $ANTLR 2.7.7 (20130428): "java-expression.g" -> "JavaRecognizer.java"$
package gnu.classpath.tools.gjdoc.expr;
import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.collections.AST;
import java.util.Hashtable;
import antlr.ASTFactory;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;
public class JavaRecognizer extends antlr.LLkParser implements JavaTokenTypes
{
protected JavaRecognizer(TokenBuffer tokenBuf, int k) {
super(tokenBuf,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public JavaRecognizer(TokenBuffer tokenBuf) {
this(tokenBuf,2);
}
protected JavaRecognizer(TokenStream lexer, int k) {
super(lexer,k);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public JavaRecognizer(TokenStream lexer) {
this(lexer,2);
}
public JavaRecognizer(ParserSharedInputState state) {
super(state,2);
tokenNames = _tokenNames;
buildTokenTypeASTClassMap();
astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}
public final Type builtInTypeSpec(
boolean addImagNode
) throws RecognitionException, TokenStreamException {
Type t = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST builtInTypeSpec_AST = null;
Token lb = null;
AST lb_AST = null;
t=builtInType();
astFactory.addASTChild(currentAST, returnAST);
{
_loop3:
do {
if ((LA(1)==LBRACK)) {
lb = LT(1);
lb_AST = astFactory.create(lb);
astFactory.makeASTRoot(currentAST, lb_AST);
match(LBRACK);
if ( inputState.guessing==0 ) {
lb_AST.setType(ARRAY_DECLARATOR);
}
match(RBRACK);
}
else {
break _loop3;
}
} while (true);
}
if ( inputState.guessing==0 ) {
builtInTypeSpec_AST = (AST)currentAST.root;
if ( addImagNode ) {
builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST));
}
currentAST.root = builtInTypeSpec_AST;
currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
currentAST.advanceChildToEnd();
}
builtInTypeSpec_AST = (AST)currentAST.root;
returnAST = builtInTypeSpec_AST;
return t;
}
public final Type builtInType() throws RecognitionException, TokenStreamException {
Type t = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST builtInType_AST = null;
switch ( LA(1)) {
case LITERAL_void:
{
AST tmp2_AST = null;
tmp2_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp2_AST);
match(LITERAL_void);
if ( inputState.guessing==0 ) {
t=Type.VOID;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_boolean:
{
AST tmp3_AST = null;
tmp3_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp3_AST);
match(LITERAL_boolean);
if ( inputState.guessing==0 ) {
t=Type.BOOLEAN;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_byte:
{
AST tmp4_AST = null;
tmp4_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp4_AST);
match(LITERAL_byte);
if ( inputState.guessing==0 ) {
t=Type.BYTE;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_char:
{
AST tmp5_AST = null;
tmp5_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp5_AST);
match(LITERAL_char);
if ( inputState.guessing==0 ) {
t=Type.CHAR;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_short:
{
AST tmp6_AST = null;
tmp6_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp6_AST);
match(LITERAL_short);
if ( inputState.guessing==0 ) {
t=Type.SHORT;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_int:
{
AST tmp7_AST = null;
tmp7_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp7_AST);
match(LITERAL_int);
if ( inputState.guessing==0 ) {
t=Type.INTEGER;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_float:
{
AST tmp8_AST = null;
tmp8_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp8_AST);
match(LITERAL_float);
if ( inputState.guessing==0 ) {
t=Type.FLOAT;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_long:
{
AST tmp9_AST = null;
tmp9_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp9_AST);
match(LITERAL_long);
if ( inputState.guessing==0 ) {
t=Type.LONG;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_double:
{
AST tmp10_AST = null;
tmp10_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp10_AST);
match(LITERAL_double);
if ( inputState.guessing==0 ) {
t=Type.DOUBLE;
}
builtInType_AST = (AST)currentAST.root;
break;
}
case LITERAL_String:
{
AST tmp11_AST = null;
tmp11_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp11_AST);
match(LITERAL_String);
if ( inputState.guessing==0 ) {
t=Type.STRING;
}
builtInType_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = builtInType_AST;
return t;
}
public final Type type() throws RecognitionException, TokenStreamException {
Type t;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST type_AST = null;
t=builtInType();
astFactory.addASTChild(currentAST, returnAST);
type_AST = (AST)currentAST.root;
returnAST = type_AST;
return t;
}
public final String identifier() throws RecognitionException, TokenStreamException {
String s = null;;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST identifier_AST = null;
Token i = null;
AST i_AST = null;
Token i2 = null;
AST i2_AST = null;
i = LT(1);
i_AST = astFactory.create(i);
astFactory.addASTChild(currentAST, i_AST);
match(IDENT);
if ( inputState.guessing==0 ) {
s=i.getText();
}
{
_loop8:
do {
if ((LA(1)==DOT)) {
AST tmp12_AST = null;
tmp12_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp12_AST);
match(DOT);
i2 = LT(1);
i2_AST = astFactory.create(i2);
astFactory.addASTChild(currentAST, i2_AST);
match(IDENT);
if ( inputState.guessing==0 ) {
s+="."+i2.getText();
}
}
else {
break _loop8;
}
} while (true);
}
identifier_AST = (AST)currentAST.root;
returnAST = identifier_AST;
return s;
}
public final Expression expression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST expression_AST = null;
e=conditionalExpression();
astFactory.addASTChild(currentAST, returnAST);
match(Token.EOF_TYPE);
expression_AST = (AST)currentAST.root;
returnAST = expression_AST;
return e;
}
public final Expression conditionalExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST conditionalExpression_AST = null;
Expression a,b,c;
e=logicalOrExpression();
astFactory.addASTChild(currentAST, returnAST);
{
switch ( LA(1)) {
case QUESTION:
{
AST tmp14_AST = null;
tmp14_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp14_AST);
match(QUESTION);
b=conditionalExpression();
astFactory.addASTChild(currentAST, returnAST);
match(COLON);
c=conditionalExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new ConditionalExpression(e,b,c);
}
break;
}
case EOF:
case COLON:
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
conditionalExpression_AST = (AST)currentAST.root;
returnAST = conditionalExpression_AST;
return e;
}
public final Expression logicalOrExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST logicalOrExpression_AST = null;
Expression a,b;
e=logicalAndExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop14:
do {
if ((LA(1)==LOR)) {
AST tmp16_AST = null;
tmp16_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp16_AST);
match(LOR);
b=logicalAndExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new LogicalOrExpression(e,b);
}
}
else {
break _loop14;
}
} while (true);
}
logicalOrExpression_AST = (AST)currentAST.root;
returnAST = logicalOrExpression_AST;
return e;
}
public final Expression logicalAndExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST logicalAndExpression_AST = null;
Expression a,b;
e=inclusiveOrExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop17:
do {
if ((LA(1)==LAND)) {
AST tmp17_AST = null;
tmp17_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp17_AST);
match(LAND);
b=inclusiveOrExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new LogicalAndExpression(e,b);
}
}
else {
break _loop17;
}
} while (true);
}
logicalAndExpression_AST = (AST)currentAST.root;
returnAST = logicalAndExpression_AST;
return e;
}
public final Expression inclusiveOrExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST inclusiveOrExpression_AST = null;
Expression a,b;
e=exclusiveOrExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop20:
do {
if ((LA(1)==BOR)) {
AST tmp18_AST = null;
tmp18_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp18_AST);
match(BOR);
b=exclusiveOrExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new InclusiveOrExpression(e,b);
}
}
else {
break _loop20;
}
} while (true);
}
inclusiveOrExpression_AST = (AST)currentAST.root;
returnAST = inclusiveOrExpression_AST;
return e;
}
public final Expression exclusiveOrExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST exclusiveOrExpression_AST = null;
Expression a,b;
e=andExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop23:
do {
if ((LA(1)==BXOR)) {
AST tmp19_AST = null;
tmp19_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp19_AST);
match(BXOR);
b=andExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new ExclusiveOrExpression(e,b);
}
}
else {
break _loop23;
}
} while (true);
}
exclusiveOrExpression_AST = (AST)currentAST.root;
returnAST = exclusiveOrExpression_AST;
return e;
}
public final Expression andExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST andExpression_AST = null;
Expression a,b;
e=equalityExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop26:
do {
if ((LA(1)==BAND)) {
AST tmp20_AST = null;
tmp20_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp20_AST);
match(BAND);
b=equalityExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new AndExpression(e,b);
}
}
else {
break _loop26;
}
} while (true);
}
andExpression_AST = (AST)currentAST.root;
returnAST = andExpression_AST;
return e;
}
public final Expression equalityExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST equalityExpression_AST = null;
Expression a,b;
e=relationalExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop30:
do {
if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
{
switch ( LA(1)) {
case NOT_EQUAL:
{
AST tmp21_AST = null;
tmp21_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp21_AST);
match(NOT_EQUAL);
a=relationalExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new NotEqualExpression(e,a);
}
break;
}
case EQUAL:
{
AST tmp22_AST = null;
tmp22_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp22_AST);
match(EQUAL);
a=relationalExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new EqualExpression(e,a);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop30;
}
} while (true);
}
equalityExpression_AST = (AST)currentAST.root;
returnAST = equalityExpression_AST;
return e;
}
public final Expression relationalExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST relationalExpression_AST = null;
Expression a,b;
e=shiftExpression();
astFactory.addASTChild(currentAST, returnAST);
{
{
_loop35:
do {
if (((LA(1) >= LT && LA(1) <= GE))) {
{
switch ( LA(1)) {
case LT:
{
AST tmp23_AST = null;
tmp23_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp23_AST);
match(LT);
a=shiftExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new LessThanExpression(e,a);
}
break;
}
case GT:
{
AST tmp24_AST = null;
tmp24_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp24_AST);
match(GT);
a=shiftExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new GreaterThanExpression(e,a);
}
break;
}
case LE:
{
AST tmp25_AST = null;
tmp25_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp25_AST);
match(LE);
a=shiftExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new LessThanOrEqualExpression(e,a);
}
break;
}
case GE:
{
AST tmp26_AST = null;
tmp26_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp26_AST);
match(GE);
a=shiftExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new GreaterThanOrEqualExpression(e,a);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop35;
}
} while (true);
}
}
relationalExpression_AST = (AST)currentAST.root;
returnAST = relationalExpression_AST;
return e;
}
public final Expression shiftExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST shiftExpression_AST = null;
Expression a,b;
e=additiveExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop39:
do {
if (((LA(1) >= SL && LA(1) <= BSR))) {
{
switch ( LA(1)) {
case SL:
{
AST tmp27_AST = null;
tmp27_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp27_AST);
match(SL);
a=additiveExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new ShiftLeftExpression(e,a);
}
break;
}
case SR:
{
AST tmp28_AST = null;
tmp28_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp28_AST);
match(SR);
a=additiveExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new ShiftRightExpression(e,a);
}
break;
}
case BSR:
{
AST tmp29_AST = null;
tmp29_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp29_AST);
match(BSR);
a=additiveExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new BitShiftRightExpression(e,a);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop39;
}
} while (true);
}
shiftExpression_AST = (AST)currentAST.root;
returnAST = shiftExpression_AST;
return e;
}
public final Expression additiveExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST additiveExpression_AST = null;
Expression a,b;
e=multiplicativeExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop43:
do {
if ((LA(1)==PLUS||LA(1)==MINUS)) {
{
switch ( LA(1)) {
case PLUS:
{
AST tmp30_AST = null;
tmp30_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp30_AST);
match(PLUS);
a=multiplicativeExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new AdditionExpression(e,a);
}
break;
}
case MINUS:
{
AST tmp31_AST = null;
tmp31_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp31_AST);
match(MINUS);
a=multiplicativeExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new SubtractionExpression(e,a);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop43;
}
} while (true);
}
additiveExpression_AST = (AST)currentAST.root;
returnAST = additiveExpression_AST;
return e;
}
public final Expression multiplicativeExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST multiplicativeExpression_AST = null;
Expression a,b;
e=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
{
_loop47:
do {
if (((LA(1) >= STAR && LA(1) <= MOD))) {
{
switch ( LA(1)) {
case STAR:
{
AST tmp32_AST = null;
tmp32_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp32_AST);
match(STAR);
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new MultiplicationExpression(e,a);
}
break;
}
case DIV:
{
AST tmp33_AST = null;
tmp33_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp33_AST);
match(DIV);
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new DivisionExpression(e,a);
}
break;
}
case MOD:
{
AST tmp34_AST = null;
tmp34_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp34_AST);
match(MOD);
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new ModuloExpression(e,a);
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else {
break _loop47;
}
} while (true);
}
multiplicativeExpression_AST = (AST)currentAST.root;
returnAST = multiplicativeExpression_AST;
return e;
}
public final Expression unaryExpression() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST unaryExpression_AST = null;
Expression a,b;
switch ( LA(1)) {
case MINUS:
{
AST tmp35_AST = null;
tmp35_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp35_AST);
match(MINUS);
if ( inputState.guessing==0 ) {
tmp35_AST.setType(UNARY_MINUS);
}
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new NegateExpression(a);
}
unaryExpression_AST = (AST)currentAST.root;
break;
}
case PLUS:
{
AST tmp36_AST = null;
tmp36_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp36_AST);
match(PLUS);
if ( inputState.guessing==0 ) {
tmp36_AST.setType(UNARY_PLUS);
}
e=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
unaryExpression_AST = (AST)currentAST.root;
break;
}
case IDENT:
case BNOT:
case LNOT:
case LPAREN:
case LITERAL_true:
case LITERAL_false:
case LITERAL_null:
case NUM_INT:
case CHAR_LITERAL:
case STRING_LITERAL:
case NUM_FLOAT:
case NUM_LONG:
case NUM_DOUBLE:
{
e=unaryExpressionNotPlusMinus();
astFactory.addASTChild(currentAST, returnAST);
unaryExpression_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = unaryExpression_AST;
return e;
}
public final Expression unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST unaryExpressionNotPlusMinus_AST = null;
Token lpb = null;
AST lpb_AST = null;
Expression a; Type t;
switch ( LA(1)) {
case BNOT:
{
AST tmp37_AST = null;
tmp37_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp37_AST);
match(BNOT);
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new NotExpression(a);
}
unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
break;
}
case LNOT:
{
AST tmp38_AST = null;
tmp38_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp38_AST);
match(LNOT);
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new LogicalNotExpression(a);
}
unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
break;
}
default:
boolean synPredMatched51 = false;
if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_String)))) {
int _m51 = mark();
synPredMatched51 = true;
inputState.guessing++;
try {
{
match(LPAREN);
builtInTypeSpec(true);
match(RPAREN);
}
}
catch (RecognitionException pe) {
synPredMatched51 = false;
}
rewind(_m51);
inputState.guessing--;
}
if ( synPredMatched51 ) {
lpb = LT(1);
lpb_AST = astFactory.create(lpb);
astFactory.makeASTRoot(currentAST, lpb_AST);
match(LPAREN);
if ( inputState.guessing==0 ) {
lpb_AST.setType(TYPECAST);
}
t=builtInTypeSpec(true);
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
a=unaryExpression();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new TypeCastExpression(t,a);
}
unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
}
else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
e=primaryExpression();
astFactory.addASTChild(currentAST, returnAST);
unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
}
else {
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = unaryExpressionNotPlusMinus_AST;
return e;
}
public final Expression primaryExpression() throws RecognitionException, TokenStreamException {
Expression e = null; String i = null;;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST primaryExpression_AST = null;
switch ( LA(1)) {
case NUM_INT:
case CHAR_LITERAL:
case STRING_LITERAL:
case NUM_FLOAT:
case NUM_LONG:
case NUM_DOUBLE:
{
e=constant();
astFactory.addASTChild(currentAST, returnAST);
primaryExpression_AST = (AST)currentAST.root;
break;
}
case IDENT:
{
i=identifier();
astFactory.addASTChild(currentAST, returnAST);
if ( inputState.guessing==0 ) {
e=new IdentifierExpression(i);
}
primaryExpression_AST = (AST)currentAST.root;
break;
}
case LITERAL_true:
{
AST tmp40_AST = null;
tmp40_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp40_AST);
match(LITERAL_true);
if ( inputState.guessing==0 ) {
e=new ConstantBoolean(true);
}
primaryExpression_AST = (AST)currentAST.root;
break;
}
case LITERAL_false:
{
AST tmp41_AST = null;
tmp41_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp41_AST);
match(LITERAL_false);
if ( inputState.guessing==0 ) {
e=new ConstantBoolean(false);
}
primaryExpression_AST = (AST)currentAST.root;
break;
}
case LITERAL_null:
{
AST tmp42_AST = null;
tmp42_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp42_AST);
match(LITERAL_null);
if ( inputState.guessing==0 ) {
e=new ConstantNull();
}
primaryExpression_AST = (AST)currentAST.root;
break;
}
case LPAREN:
{
match(LPAREN);
e=conditionalExpression();
astFactory.addASTChild(currentAST, returnAST);
match(RPAREN);
primaryExpression_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = primaryExpression_AST;
return e;
}
public final Expression constant() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST constant_AST = null;
Token l1 = null;
AST l1_AST = null;
Token l2 = null;
AST l2_AST = null;
Token l3 = null;
AST l3_AST = null;
Token l4 = null;
AST l4_AST = null;
Token l5 = null;
AST l5_AST = null;
Token l6 = null;
AST l6_AST = null;
switch ( LA(1)) {
case NUM_INT:
{
l1 = LT(1);
l1_AST = astFactory.create(l1);
astFactory.addASTChild(currentAST, l1_AST);
match(NUM_INT);
if ( inputState.guessing==0 ) {
e=new ConstantInteger(l1.getText());
}
constant_AST = (AST)currentAST.root;
break;
}
case CHAR_LITERAL:
{
l2 = LT(1);
l2_AST = astFactory.create(l2);
astFactory.addASTChild(currentAST, l2_AST);
match(CHAR_LITERAL);
if ( inputState.guessing==0 ) {
e=new ConstantChar(l2.getText());
}
constant_AST = (AST)currentAST.root;
break;
}
case STRING_LITERAL:
{
l3 = LT(1);
l3_AST = astFactory.create(l3);
astFactory.addASTChild(currentAST, l3_AST);
match(STRING_LITERAL);
if ( inputState.guessing==0 ) {
e=new ConstantString(l3.getText().substring(1, l3.getText().length()-1));
}
constant_AST = (AST)currentAST.root;
break;
}
case NUM_FLOAT:
{
l4 = LT(1);
l4_AST = astFactory.create(l4);
astFactory.addASTChild(currentAST, l4_AST);
match(NUM_FLOAT);
if ( inputState.guessing==0 ) {
e=new ConstantFloat(l4.getText());
}
constant_AST = (AST)currentAST.root;
break;
}
case NUM_LONG:
{
l5 = LT(1);
l5_AST = astFactory.create(l5);
astFactory.addASTChild(currentAST, l5_AST);
match(NUM_LONG);
if ( inputState.guessing==0 ) {
e=new ConstantLong(l5.getText());
}
constant_AST = (AST)currentAST.root;
break;
}
case NUM_DOUBLE:
{
l6 = LT(1);
l6_AST = astFactory.create(l6);
astFactory.addASTChild(currentAST, l6_AST);
match(NUM_DOUBLE);
if ( inputState.guessing==0 ) {
e=new ConstantDouble(l6.getText());
}
constant_AST = (AST)currentAST.root;
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
returnAST = constant_AST;
return e;
}
/** Match a, a.b.c refs
*/
public final Expression identPrimary() throws RecognitionException, TokenStreamException {
Expression e = null;
returnAST = null;
ASTPair currentAST = new ASTPair();
AST identPrimary_AST = null;
AST tmp45_AST = null;
tmp45_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp45_AST);
match(IDENT);
{
_loop55:
do {
if ((LA(1)==DOT)) {
AST tmp46_AST = null;
tmp46_AST = astFactory.create(LT(1));
astFactory.makeASTRoot(currentAST, tmp46_AST);
match(DOT);
AST tmp47_AST = null;
tmp47_AST = astFactory.create(LT(1));
astFactory.addASTChild(currentAST, tmp47_AST);
match(IDENT);
}
else {
break _loop55;
}
} while (true);
}
identPrimary_AST = (AST)currentAST.root;
returnAST = identPrimary_AST;
return e;
}
public static final String[] _tokenNames = {
"<0>",
"EOF",
"<2>",
"NULL_TREE_LOOKAHEAD",
"BLOCK",
"MODIFIERS",
"OBJBLOCK",
"SLIST",
"CTOR_DEF",
"METHOD_DEF",
"VARIABLE_DEF",
"INSTANCE_INIT",
"STATIC_INIT",
"TYPE",
"CLASS_DEF",
"INTERFACE_DEF",
"PACKAGE_DEF",
"ARRAY_DECLARATOR",
"EXTENDS_CLAUSE",
"IMPLEMENTS_CLAUSE",
"PARAMETERS",
"PARAMETER_DEF",
"LABELED_STAT",
"TYPECAST",
"INDEX_OP",
"POST_INC",
"POST_DEC",
"METHOD_CALL",
"EXPR",
"ARRAY_INIT",
"IMPORT",
"UNARY_MINUS",
"UNARY_PLUS",
"CASE_GROUP",
"ELIST",
"FOR_INIT",
"FOR_CONDITION",
"FOR_ITERATOR",
"EMPTY_STAT",
"\"final\"",
"\"abstract\"",
"\"strictfp\"",
"SUPER_CTOR_CALL",
"CTOR_CALL",
"LBRACK",
"RBRACK",
"\"void\"",
"\"boolean\"",
"\"byte\"",
"\"char\"",
"\"short\"",
"\"int\"",
"\"float\"",
"\"long\"",
"\"double\"",
"\"String\"",
"IDENT",
"DOT",
"QUESTION",
"COLON",
"LOR",
"LAND",
"BOR",
"BXOR",
"BAND",
"NOT_EQUAL",
"EQUAL",
"LT",
"GT",
"LE",
"GE",
"SL",
"SR",
"BSR",
"PLUS",
"MINUS",
"STAR",
"DIV",
"MOD",
"BNOT",
"LNOT",
"LPAREN",
"RPAREN",
"\"true\"",
"\"false\"",
"\"null\"",
"NUM_INT",
"CHAR_LITERAL",
"STRING_LITERAL",
"NUM_FLOAT",
"NUM_LONG",
"NUM_DOUBLE",
"LCURLY",
"RCURLY",
"COMMA",
"ASSIGN",
"DIV_ASSIGN",
"PLUS_ASSIGN",
"INC",
"MINUS_ASSIGN",
"DEC",
"STAR_ASSIGN",
"MOD_ASSIGN",
"SR_ASSIGN",
"BSR_ASSIGN",
"SL_ASSIGN",
"BXOR_ASSIGN",
"BOR_ASSIGN",
"BAND_ASSIGN",
"SEMI",
"WS",
"SL_COMMIT",
"ML_COMMENT",
"ESC",
"HEX_DIGIT",
"VOCAB",
"EXPONENT",
"FLOAT_SUFFIX"
};
protected void buildTokenTypeASTClassMap() {
tokenTypeToASTClassMap=null;
};
private static final long[] mk_tokenSet_0() {
long[] data = { 72057594037927936L, 268042240L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
private static final long[] mk_tokenSet_1() {
long[] data = { -72057594037927934L, 268435455L, 0L, 0L};
return data;
}
public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
}