summaryrefslogtreecommitdiff
path: root/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java
diff options
context:
space:
mode:
Diffstat (limited to 'tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java')
-rw-r--r--tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java1406
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());
+
+ }
View Lorry Controller Status