| // $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()); |
| |
| } |