diff options
author | farshadmuhammad <farshadmuhammad@cmail.carleton.ca> | 2013-09-01 21:21:33 -0400 |
---|---|---|
committer | farshadmuhammad <farshadmuhammad@cmail.carleton.ca> | 2013-09-01 21:21:33 -0400 |
commit | 848e38a011eb5ae3e0c715253f37d0b4a412b032 (patch) | |
tree | c80b9e330f428d1e2261710584c1c07c10c61ae3 /tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java | |
parent | b8b72a7bb7f3a822c7ba290f1b9aef386b80ccbf (diff) | |
download | classpath-848e38a011eb5ae3e0c715253f37d0b4a412b032.tar.gz |
Cleaned Up Code and removed print statements
Diffstat (limited to 'tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java')
-rw-r--r-- | tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java | 1406 |
1 files changed, 1406 insertions, 0 deletions
diff --git a/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java b/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java new file mode 100644 index 000000000..b435d8880 --- /dev/null +++ b/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java @@ -0,0 +1,1406 @@ +// $ANTLR 2.7.7 (20120518): "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()); + + } |