Subversion Repositories openrisc

// $ANTLR 2.7.7 (20080530): "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());
 
        }