| /* |
| * Copyright (C) 2011 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.doclava.parser; |
| |
| import org.antlr.runtime.BaseRecognizer; |
| import org.antlr.runtime.BitSet; |
| import org.antlr.runtime.DFA; |
| import org.antlr.runtime.EarlyExitException; |
| import org.antlr.runtime.IntStream; |
| import org.antlr.runtime.MismatchedSetException; |
| import org.antlr.runtime.NoViableAltException; |
| import org.antlr.runtime.RecognitionException; |
| import org.antlr.runtime.RecognizerSharedState; |
| import org.antlr.runtime.TokenStream; |
| import org.antlr.runtime.debug.DebugEventListener; |
| import org.antlr.runtime.debug.DebugEventSocketProxy; |
| import org.antlr.runtime.debug.DebugParser; |
| |
| import java.io.IOException; |
| import java.util.HashMap; |
| /** A Java 1.5 grammar for ANTLR v3 derived from the spec |
| * |
| * This is a very close representation of the spec; the changes |
| * are comestic (remove left recursion) and also fixes (the spec |
| * isn't exactly perfect). I have run this on the 1.4.2 source |
| * and some nasty looking enums from 1.5, but have not really |
| * tested for 1.5 compatibility. |
| * |
| * I built this with: java -Xmx100M org.antlr.Tool java.g |
| * and got two errors that are ok (for now): |
| * java.g:691:9: Decision can match input such as |
| * "'0'..'9'{'E', 'e'}{'+', '-'}'0'..'9'{'D', 'F', 'd', 'f'}" |
| * using multiple alternatives: 3, 4 |
| * As a result, alternative(s) 4 were disabled for that input |
| * java.g:734:35: Decision can match input such as "{'$', 'A'..'Z', |
| * '_', 'a'..'z', '\u00C0'..'\u00D6', '\u00D8'..'\u00F6', |
| * '\u00F8'..'\u1FFF', '\u3040'..'\u318F', '\u3300'..'\u337F', |
| * '\u3400'..'\u3D2D', '\u4E00'..'\u9FFF', '\uF900'..'\uFAFF'}" |
| * using multiple alternatives: 1, 2 |
| * As a result, alternative(s) 2 were disabled for that input |
| * |
| * You can turn enum on/off as a keyword :) |
| * |
| * Version 1.0 -- initial release July 5, 2006 (requires 3.0b2 or higher) |
| * |
| * Primary author: Terence Parr, July 2006 |
| * |
| * Version 1.0.1 -- corrections by Koen Vanderkimpen & Marko van Dooren, |
| * October 25, 2006; |
| * fixed normalInterfaceDeclaration: now uses typeParameters instead |
| * of typeParameter (according to JLS, 3rd edition) |
| * fixed castExpression: no longer allows expression next to type |
| * (according to semantics in JLS, in contrast with syntax in JLS) |
| * |
| * Version 1.0.2 -- Terence Parr, Nov 27, 2006 |
| * java spec I built this from had some bizarre for-loop control. |
| * Looked weird and so I looked elsewhere...Yep, it's messed up. |
| * simplified. |
| * |
| * Version 1.0.3 -- Chris Hogue, Feb 26, 2007 |
| * Factored out an annotationName rule and used it in the annotation rule. |
| * Not sure why, but typeName wasn't recognizing references to inner |
| * annotations (e.g. @InterfaceName.InnerAnnotation()) |
| * Factored out the elementValue section of an annotation reference. Created |
| * elementValuePair and elementValuePairs rules, then used them in the |
| * annotation rule. Allows it to recognize annotation references with |
| * multiple, comma separated attributes. |
| * Updated elementValueArrayInitializer so that it allows multiple elements. |
| * (It was only allowing 0 or 1 element). |
| * Updated localVariableDeclaration to allow annotations. Interestingly the JLS |
| * doesn't appear to indicate this is legal, but it does work as of at least |
| * JDK 1.5.0_06. |
| * Moved the Identifier portion of annotationTypeElementRest to annotationMethodRest. |
| * Because annotationConstantRest already references variableDeclarator which |
| * has the Identifier portion in it, the parser would fail on constants in |
| * annotation definitions because it expected two identifiers. |
| * Added optional trailing ';' to the alternatives in annotationTypeElementRest. |
| * Wouldn't handle an inner interface that has a trailing ';'. |
| * Swapped the expression and type rule reference order in castExpression to |
| * make it check for genericized casts first. It was failing to recognize a |
| * statement like "Class<Byte> TYPE = (Class<Byte>)...;" because it was seeing |
| * 'Class<Byte' in the cast expression as a less than expression, then failing |
| * on the '>'. |
| * Changed createdName to use typeArguments instead of nonWildcardTypeArguments. |
| * |
| * Changed the 'this' alternative in primary to allow 'identifierSuffix' rather than |
| * just 'arguments'. The case it couldn't handle was a call to an explicit |
| * generic method invocation (e.g. this.<E>doSomething()). Using identifierSuffix |
| * may be overly aggressive--perhaps should create a more constrained thisSuffix rule? |
| * |
| * Version 1.0.4 -- Hiroaki Nakamura, May 3, 2007 |
| * |
| * Fixed formalParameterDecls, localVariableDeclaration, forInit, |
| * and forVarControl to use variableModifier* not 'final'? (annotation)? |
| * |
| * Version 1.0.5 -- Terence, June 21, 2007 |
| * --a[i].foo didn't work. Fixed unaryExpression |
| * |
| * Version 1.0.6 -- John Ridgway, March 17, 2008 |
| * Made "assert" a switchable keyword like "enum". |
| * Fixed compilationUnit to disallow "annotation importDeclaration ...". |
| * Changed "Identifier ('.' Identifier)*" to "qualifiedName" in more |
| * places. |
| * Changed modifier* and/or variableModifier* to classOrInterfaceModifiers, |
| * modifiers or variableModifiers, as appropriate. |
| * Renamed "bound" to "typeBound" to better match language in the JLS. |
| * Added "memberDeclaration" which rewrites to methodDeclaration or |
| * fieldDeclaration and pulled type into memberDeclaration. So we parse |
| * type and then move on to decide whether we're dealing with a field |
| * or a method. |
| * Modified "constructorDeclaration" to use "constructorBody" instead of |
| * "methodBody". constructorBody starts with explicitConstructorInvocation, |
| * then goes on to blockStatement*. Pulling explicitConstructorInvocation |
| * out of expressions allowed me to simplify "primary". |
| * Changed variableDeclarator to simplify it. |
| * Changed type to use classOrInterfaceType, thus simplifying it; of course |
| * I then had to add classOrInterfaceType, but it is used in several |
| * places. |
| * Fixed annotations, old version allowed "@X(y,z)", which is illegal. |
| * Added optional comma to end of "elementValueArrayInitializer"; as per JLS. |
| * Changed annotationTypeElementRest to use normalClassDeclaration and |
| * normalInterfaceDeclaration rather than classDeclaration and |
| * interfaceDeclaration, thus getting rid of a couple of grammar ambiguities. |
| * Split localVariableDeclaration into localVariableDeclarationStatement |
| * (includes the terminating semi-colon) and localVariableDeclaration. |
| * This allowed me to use localVariableDeclaration in "forInit" clauses, |
| * simplifying them. |
| * Changed switchBlockStatementGroup to use multiple labels. This adds an |
| * ambiguity, but if one uses appropriately greedy parsing it yields the |
| * parse that is closest to the meaning of the switch statement. |
| * Renamed "forVarControl" to "enhancedForControl" -- JLS language. |
| * Added semantic predicates to test for shift operations rather than other |
| * things. Thus, for instance, the string "< <" will never be treated |
| * as a left-shift operator. |
| * In "creator" we rule out "nonWildcardTypeArguments" on arrayCreation, |
| * which are illegal. |
| * Moved "nonWildcardTypeArguments into innerCreator. |
| * Removed 'super' superSuffix from explicitGenericInvocation, since that |
| * is only used in explicitConstructorInvocation at the beginning of a |
| * constructorBody. (This is part of the simplification of expressions |
| * mentioned earlier.) |
| * Simplified primary (got rid of those things that are only used in |
| * explicitConstructorInvocation). |
| * Lexer -- removed "Exponent?" from FloatingPointLiteral choice 4, since it |
| * led to an ambiguity. |
| * |
| * This grammar successfully parses every .java file in the JDK 1.5 source |
| * tree (excluding those whose file names include '-', which are not |
| * valid Java compilation units). |
| * |
| * Known remaining problems: |
| * "Letter" and "JavaIDDigit" are wrong. The actual specification of |
| * "Letter" should be "a character for which the method |
| * Character.isJavaIdentifierStart(int) returns true." A "Java |
| * letter-or-digit is a character for which the method |
| * Character.isJavaIdentifierPart(int) returns true." |
| */ |
| public class JavaParser extends DebugParser { |
| public static final String[] tokenNames = new String[] { |
| "<invalid>", "<EOR>", "<DOWN>", "<UP>", "IDENTIFIER", "INTLITERAL", "LONGLITERAL", "FLOATLITERAL", "DOUBLELITERAL", "CHARLITERAL", "STRINGLITERAL", "TRUE", "FALSE", "NULL", "IntegerNumber", "LongSuffix", "HexPrefix", "HexDigit", "Exponent", "NonIntegerNumber", "FloatSuffix", "DoubleSuffix", "EscapeSequence", "UNICODECHAR", "UNICODEPART", "WS", "COMMENT", "LINE_COMMENT", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "GOTO", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "SEMI", "COMMA", "DOT", "ELLIPSIS", "EQ", "BANG", "TILDE", "QUES", "COLON", "EQEQ", "AMPAMP", "BARBAR", "PLUSPLUS", "SUBSUB", "PLUS", "SUB", "STAR", "SLASH", "AMP", "BAR", "CARET", "PERCENT", "PLUSEQ", "SUBEQ", "STAREQ", "SLASHEQ", "AMPEQ", "BAREQ", "CARETEQ", "PERCENTEQ", "MONKEYS_AT", "BANGEQ", "GT", "LT", "IdentifierStart", "IdentifierPart", "SurrogateIdentifer" |
| }; |
| public static final int EOF=-1; |
| public static final int IDENTIFIER=4; |
| public static final int INTLITERAL=5; |
| public static final int LONGLITERAL=6; |
| public static final int FLOATLITERAL=7; |
| public static final int DOUBLELITERAL=8; |
| public static final int CHARLITERAL=9; |
| public static final int STRINGLITERAL=10; |
| public static final int TRUE=11; |
| public static final int FALSE=12; |
| public static final int NULL=13; |
| public static final int IntegerNumber=14; |
| public static final int LongSuffix=15; |
| public static final int HexPrefix=16; |
| public static final int HexDigit=17; |
| public static final int Exponent=18; |
| public static final int NonIntegerNumber=19; |
| public static final int FloatSuffix=20; |
| public static final int DoubleSuffix=21; |
| public static final int EscapeSequence=22; |
| public static final int UNICODECHAR=23; |
| public static final int UNICODEPART=24; |
| public static final int WS=25; |
| public static final int COMMENT=26; |
| public static final int LINE_COMMENT=27; |
| public static final int ABSTRACT=28; |
| public static final int ASSERT=29; |
| public static final int BOOLEAN=30; |
| public static final int BREAK=31; |
| public static final int BYTE=32; |
| public static final int CASE=33; |
| public static final int CATCH=34; |
| public static final int CHAR=35; |
| public static final int CLASS=36; |
| public static final int CONST=37; |
| public static final int CONTINUE=38; |
| public static final int DEFAULT=39; |
| public static final int DO=40; |
| public static final int DOUBLE=41; |
| public static final int ELSE=42; |
| public static final int ENUM=43; |
| public static final int EXTENDS=44; |
| public static final int FINAL=45; |
| public static final int FINALLY=46; |
| public static final int FLOAT=47; |
| public static final int FOR=48; |
| public static final int GOTO=49; |
| public static final int IF=50; |
| public static final int IMPLEMENTS=51; |
| public static final int IMPORT=52; |
| public static final int INSTANCEOF=53; |
| public static final int INT=54; |
| public static final int INTERFACE=55; |
| public static final int LONG=56; |
| public static final int NATIVE=57; |
| public static final int NEW=58; |
| public static final int PACKAGE=59; |
| public static final int PRIVATE=60; |
| public static final int PROTECTED=61; |
| public static final int PUBLIC=62; |
| public static final int RETURN=63; |
| public static final int SHORT=64; |
| public static final int STATIC=65; |
| public static final int STRICTFP=66; |
| public static final int SUPER=67; |
| public static final int SWITCH=68; |
| public static final int SYNCHRONIZED=69; |
| public static final int THIS=70; |
| public static final int THROW=71; |
| public static final int THROWS=72; |
| public static final int TRANSIENT=73; |
| public static final int TRY=74; |
| public static final int VOID=75; |
| public static final int VOLATILE=76; |
| public static final int WHILE=77; |
| public static final int LPAREN=78; |
| public static final int RPAREN=79; |
| public static final int LBRACE=80; |
| public static final int RBRACE=81; |
| public static final int LBRACKET=82; |
| public static final int RBRACKET=83; |
| public static final int SEMI=84; |
| public static final int COMMA=85; |
| public static final int DOT=86; |
| public static final int ELLIPSIS=87; |
| public static final int EQ=88; |
| public static final int BANG=89; |
| public static final int TILDE=90; |
| public static final int QUES=91; |
| public static final int COLON=92; |
| public static final int EQEQ=93; |
| public static final int AMPAMP=94; |
| public static final int BARBAR=95; |
| public static final int PLUSPLUS=96; |
| public static final int SUBSUB=97; |
| public static final int PLUS=98; |
| public static final int SUB=99; |
| public static final int STAR=100; |
| public static final int SLASH=101; |
| public static final int AMP=102; |
| public static final int BAR=103; |
| public static final int CARET=104; |
| public static final int PERCENT=105; |
| public static final int PLUSEQ=106; |
| public static final int SUBEQ=107; |
| public static final int STAREQ=108; |
| public static final int SLASHEQ=109; |
| public static final int AMPEQ=110; |
| public static final int BAREQ=111; |
| public static final int CARETEQ=112; |
| public static final int PERCENTEQ=113; |
| public static final int MONKEYS_AT=114; |
| public static final int BANGEQ=115; |
| public static final int GT=116; |
| public static final int LT=117; |
| public static final int IdentifierStart=118; |
| public static final int IdentifierPart=119; |
| public static final int SurrogateIdentifer=120; |
| |
| // delegates |
| // delegators |
| |
| public static final String[] ruleNames = new String[] { |
| "invalidRule", "typeList", "synpred114_Java", "synpred175_Java", |
| "synpred19_Java", "elementValuePairs", "identifierSuffix", "interfaceFieldDeclaration", |
| "synpred69_Java", "synpred263_Java", "synpred231_Java", "synpred267_Java", |
| "synpred111_Java", "block", "synpred261_Java", "elementValuePair", |
| "typeArgument", "synpred264_Java", "synpred95_Java", "synpred93_Java", |
| "synpred215_Java", "normalInterfaceDeclaration", "enumHeader", "synpred236_Java", |
| "createdName", "synpred271_Java", "synpred230_Java", "synpred30_Java", |
| "synpred212_Java", "synpred82_Java", "synpred128_Java", "synpred83_Java", |
| "synpred255_Java", "synpred190_Java", "arrayInitializer", "interfaceDeclaration", |
| "synpred92_Java", "localVariableHeader", "packageDeclaration", "formalParameter", |
| "catchClause", "synpred27_Java", "synpred270_Java", "synpred46_Java", |
| "synpred1_Java", "synpred4_Java", "synpred233_Java", "synpred120_Java", |
| "superSuffix", "literal", "classDeclaration", "synpred72_Java", |
| "synpred160_Java", "arguments", "synpred80_Java", "formalParameterDecls", |
| "synpred113_Java", "inclusiveOrExpression", "synpred71_Java", "selector", |
| "synpred194_Java", "synpred265_Java", "synpred173_Java", "synpred141_Java", |
| "synpred187_Java", "trystatement", "synpred133_Java", "interfaceHeader", |
| "synpred73_Java", "localVariableDeclarationStatement", "synpred102_Java", |
| "synpred90_Java", "equalityExpression", "synpred177_Java", "synpred149_Java", |
| "interfaceBodyDeclaration", "classCreatorRest", "synpred121_Java", |
| "synpred105_Java", "typeArguments", "synpred60_Java", "synpred195_Java", |
| "fieldDeclaration", "synpred269_Java", "synpred250_Java", "multiplicativeExpression", |
| "qualifiedNameList", "synpred86_Java", "synpred148_Java", "synpred142_Java", |
| "synpred65_Java", "synpred75_Java", "synpred235_Java", "synpred192_Java", |
| "synpred144_Java", "castExpression", "enumBody", "synpred70_Java", |
| "synpred33_Java", "synpred54_Java", "annotationTypeDeclaration", |
| "annotationHeader", "synpred107_Java", "synpred35_Java", "creator", |
| "nonWildcardTypeArguments", "variableInitializer", "enumConstants", |
| "synpred34_Java", "interfaceMethodDeclaration", "type", "synpred135_Java", |
| "synpred119_Java", "conditionalAndExpression", "synpred9_Java", |
| "synpred125_Java", "synpred40_Java", "synpred257_Java", "enumConstant", |
| "synpred143_Java", "synpred132_Java", "synpred146_Java", "synpred188_Java", |
| "ellipsisParameterDecl", "synpred245_Java", "synpred167_Java", "compilationUnit", |
| "synpred259_Java", "synpred64_Java", "synpred181_Java", "synpred23_Java", |
| "synpred12_Java", "synpred74_Java", "explicitConstructorInvocation", |
| "synpred266_Java", "synpred197_Java", "synpred147_Java", "synpred15_Java", |
| "synpred178_Java", "synpred174_Java", "exclusiveOrExpression", "forstatement", |
| "synpred7_Java", "synpred76_Java", "synpred224_Java", "parExpression", |
| "synpred241_Java", "synpred159_Java", "synpred260_Java", "synpred50_Java", |
| "synpred166_Java", "annotationMethodDeclaration", "synpred208_Java", |
| "synpred106_Java", "classOrInterfaceType", "qualifiedImportName", |
| "statement", "typeBound", "methodHeader", "synpred249_Java", "synpred55_Java", |
| "synpred131_Java", "classBodyDeclaration", "synpred189_Java", "synpred51_Java", |
| "synpred227_Java", "synpred220_Java", "synpred123_Java", "andExpression", |
| "synpred200_Java", "synpred165_Java", "relationalExpression", "annotationTypeBody", |
| "synpred210_Java", "synpred109_Java", "conditionalOrExpression", |
| "synpred161_Java", "classOrInterfaceDeclaration", "synpred180_Java", |
| "synpred154_Java", "elementValueArrayInitializer", "synpred14_Java", |
| "innerCreator", "synpred26_Java", "synpred52_Java", "synpred198_Java", |
| "synpred219_Java", "synpred126_Java", "synpred85_Java", "synpred88_Java", |
| "synpred68_Java", "synpred3_Java", "synpred203_Java", "annotations", |
| "elementValue", "synpred205_Java", "synpred6_Java", "synpred32_Java", |
| "synpred209_Java", "assignmentOperator", "synpred262_Java", "synpred139_Java", |
| "synpred29_Java", "synpred204_Java", "synpred118_Java", "synpred94_Java", |
| "synpred84_Java", "synpred63_Java", "conditionalExpression", "synpred56_Java", |
| "synpred162_Java", "primitiveType", "synpred240_Java", "synpred216_Java", |
| "synpred79_Java", "synpred99_Java", "additiveExpression", "synpred78_Java", |
| "modifiers", "synpred184_Java", "synpred168_Java", "synpred48_Java", |
| "switchBlockStatementGroups", "blockStatement", "synpred193_Java", |
| "classBody", "interfaceBody", "synpred67_Java", "synpred5_Java", |
| "synpred58_Java", "synpred254_Java", "localVariableDeclaration", |
| "annotationTypeElementDeclaration", "synpred251_Java", "arrayCreator", |
| "synpred226_Java", "synpred239_Java", "synpred191_Java", "synpred24_Java", |
| "normalClassDeclaration", "synpred98_Java", "synpred53_Java", "synpred145_Java", |
| "synpred22_Java", "synpred150_Java", "synpred238_Java", "synpred207_Java", |
| "variableModifiers", "typeParameters", "synpred38_Java", "synpred129_Java", |
| "enumBodyDeclarations", "synpred172_Java", "synpred16_Java", "synpred100_Java", |
| "fieldHeader", "synpred41_Java", "synpred248_Java", "synpred152_Java", |
| "synpred214_Java", "switchBlockStatementGroup", "synpred199_Java", |
| "switchLabel", "qualifiedName", "synpred137_Java", "synpred237_Java", |
| "synpred223_Java", "synpred156_Java", "synpred243_Java", "synpred182_Java", |
| "synpred138_Java", "synpred77_Java", "synpred127_Java", "synpred112_Java", |
| "unaryExpressionNotPlusMinus", "synpred42_Java", "synpred89_Java", |
| "formalParameters", "synpred225_Java", "synpred136_Java", "synpred186_Java", |
| "synpred122_Java", "synpred87_Java", "synpred244_Java", "synpred97_Java", |
| "synpred229_Java", "synpred170_Java", "shiftOp", "synpred134_Java", |
| "synpred253_Java", "synpred44_Java", "memberDecl", "synpred157_Java", |
| "synpred246_Java", "synpred49_Java", "synpred31_Java", "synpred256_Java", |
| "unaryExpression", "synpred13_Java", "synpred213_Java", "synpred155_Java", |
| "typeHeader", "synpred91_Java", "instanceOfExpression", "variableDeclarator", |
| "synpred140_Java", "synpred25_Java", "synpred117_Java", "synpred2_Java", |
| "synpred222_Java", "synpred10_Java", "synpred104_Java", "synpred115_Java", |
| "synpred221_Java", "synpred45_Java", "synpred211_Java", "typeParameter", |
| "synpred36_Java", "synpred103_Java", "synpred39_Java", "synpred201_Java", |
| "methodDeclaration", "synpred62_Java", "synpred110_Java", "classHeader", |
| "synpred101_Java", "synpred21_Java", "synpred196_Java", "synpred96_Java", |
| "synpred61_Java", "synpred228_Java", "synpred28_Java", "synpred218_Java", |
| "synpred179_Java", "normalParameterDecl", "enumDeclaration", "synpred17_Java", |
| "synpred18_Java", "synpred108_Java", "synpred43_Java", "synpred206_Java", |
| "synpred169_Java", "synpred130_Java", "synpred242_Java", "synpred252_Java", |
| "synpred151_Java", "forInit", "shiftExpression", "synpred81_Java", |
| "synpred247_Java", "synpred20_Java", "catches", "synpred202_Java", |
| "synpred47_Java", "synpred185_Java", "synpred158_Java", "synpred66_Java", |
| "synpred11_Java", "synpred8_Java", "synpred163_Java", "synpred217_Java", |
| "primary", "synpred153_Java", "synpred57_Java", "synpred258_Java", |
| "expressionList", "annotation", "expression", "synpred176_Java", |
| "synpred171_Java", "synpred164_Java", "importDeclaration", "synpred124_Java", |
| "synpred268_Java", "synpred234_Java", "relationalOp", "synpred59_Java", |
| "synpred37_Java", "synpred183_Java", "synpred232_Java", "synpred116_Java", |
| "typeDeclaration" |
| }; |
| public static final boolean[] decisionCanBacktrack = new boolean[] { |
| false, // invalid decision |
| false, true, false, false, false, false, false, false, false, false, |
| false, true, false, false, true, false, false, false, false, |
| false, false, false, false, false, false, false, false, false, |
| false, false, true, false, false, false, false, false, false, |
| false, true, false, false, true, false, false, false, false, |
| false, false, true, false, false, false, true, false, false, |
| false, false, false, false, false, false, false, false, false, |
| false, false, false, false, false, false, true, true, false, |
| false, false, true, false, false, false, false, false, false, |
| false, false, false, false, true, false, false, true, false, |
| false, false, true, false, false, false, true, false, false, |
| false, true, false, false, false, false, false, true, true, |
| false, false, false, false, false, false, false, false, false, |
| false, false, false, false, false, false, false, false, false, |
| false, false, true, true, true, true, true, true, false, false, |
| false, false, false, false, true, false, false, false, true, |
| false, true, false, true, false, false, false, false, false, |
| false, false, false, false, false, false, false, false, false, |
| false, false, false, false, false, false, true, false, false, |
| false, false, false, false, false, false, false, false, false, |
| false, false, false, false, false, false, false, false, false, |
| false, false, false |
| }; |
| |
| |
| public int ruleLevel = 0; |
| public int getRuleLevel() { return ruleLevel; } |
| public void incRuleLevel() { ruleLevel++; } |
| public void decRuleLevel() { ruleLevel--; } |
| public JavaParser(TokenStream input) { |
| this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState()); |
| } |
| public JavaParser(TokenStream input, int port, RecognizerSharedState state) { |
| super(input, state); |
| this.state.ruleMemo = new HashMap[381+1]; |
| |
| DebugEventSocketProxy proxy = |
| new DebugEventSocketProxy(this, port, null); |
| setDebugListener(proxy); |
| try { |
| proxy.handshake(); |
| } |
| catch (IOException ioe) { |
| reportError(ioe); |
| } |
| } |
| public JavaParser(TokenStream input, DebugEventListener dbg) { |
| super(input, dbg, new RecognizerSharedState()); |
| this.state.ruleMemo = new HashMap[381+1]; |
| |
| } |
| protected boolean evalPredicate(boolean result, String predicate) { |
| dbg.semanticPredicate(result, predicate); |
| return result; |
| } |
| |
| |
| public String[] getTokenNames() { return JavaParser.tokenNames; } |
| public String getGrammarFileName() { return "src/com/google/doclava/parser/Java.g"; } |
| |
| |
| |
| // $ANTLR start "compilationUnit" |
| // src/com/google/doclava/parser/Java.g:293:1: compilationUnit : ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ; |
| public final void compilationUnit() throws RecognitionException { |
| int compilationUnit_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "compilationUnit"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(293, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:298:5: ( ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* |
| { |
| dbg.location(298,9); |
| // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )? |
| int alt2=2; |
| try { dbg.enterSubRule(2); |
| try { dbg.enterDecision(2, decisionCanBacktrack[2]); |
| |
| try { |
| isCyclicDecision = true; |
| alt2 = dfa2.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(2);} |
| |
| switch (alt2) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration |
| { |
| dbg.location(298,13); |
| // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? |
| int alt1=2; |
| try { dbg.enterSubRule(1); |
| try { dbg.enterDecision(1, decisionCanBacktrack[1]); |
| |
| int LA1_0 = input.LA(1); |
| |
| if ( (LA1_0==MONKEYS_AT) ) { |
| alt1=1; |
| } |
| } finally {dbg.exitDecision(1);} |
| |
| switch (alt1) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:298:14: annotations |
| { |
| dbg.location(298,14); |
| pushFollow(FOLLOW_annotations_in_compilationUnit64); |
| annotations(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(1);} |
| |
| dbg.location(300,13); |
| pushFollow(FOLLOW_packageDeclaration_in_compilationUnit93); |
| packageDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(2);} |
| |
| dbg.location(302,9); |
| // src/com/google/doclava/parser/Java.g:302:9: ( importDeclaration )* |
| try { dbg.enterSubRule(3); |
| |
| loop3: |
| do { |
| int alt3=2; |
| try { dbg.enterDecision(3, decisionCanBacktrack[3]); |
| |
| int LA3_0 = input.LA(1); |
| |
| if ( (LA3_0==IMPORT) ) { |
| alt3=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(3);} |
| |
| switch (alt3) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:302:10: importDeclaration |
| { |
| dbg.location(302,10); |
| pushFollow(FOLLOW_importDeclaration_in_compilationUnit115); |
| importDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop3; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(3);} |
| |
| dbg.location(304,9); |
| // src/com/google/doclava/parser/Java.g:304:9: ( typeDeclaration )* |
| try { dbg.enterSubRule(4); |
| |
| loop4: |
| do { |
| int alt4=2; |
| try { dbg.enterDecision(4, decisionCanBacktrack[4]); |
| |
| int LA4_0 = input.LA(1); |
| |
| if ( (LA4_0==IDENTIFIER||LA4_0==ABSTRACT||LA4_0==BOOLEAN||LA4_0==BYTE||(LA4_0>=CHAR && LA4_0<=CLASS)||LA4_0==DOUBLE||LA4_0==ENUM||LA4_0==FINAL||LA4_0==FLOAT||(LA4_0>=INT && LA4_0<=NATIVE)||(LA4_0>=PRIVATE && LA4_0<=PUBLIC)||(LA4_0>=SHORT && LA4_0<=STRICTFP)||LA4_0==SYNCHRONIZED||LA4_0==TRANSIENT||(LA4_0>=VOID && LA4_0<=VOLATILE)||LA4_0==SEMI||LA4_0==MONKEYS_AT||LA4_0==LT) ) { |
| alt4=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(4);} |
| |
| switch (alt4) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:304:10: typeDeclaration |
| { |
| dbg.location(304,10); |
| pushFollow(FOLLOW_typeDeclaration_in_compilationUnit137); |
| typeDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop4; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(4);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); } |
| } |
| dbg.location(306, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "compilationUnit"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "compilationUnit" |
| |
| |
| // $ANTLR start "packageDeclaration" |
| // src/com/google/doclava/parser/Java.g:308:1: packageDeclaration : 'package' qualifiedName ';' ; |
| public final void packageDeclaration() throws RecognitionException { |
| int packageDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "packageDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(308, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:309:5: ( 'package' qualifiedName ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:309:9: 'package' qualifiedName ';' |
| { |
| dbg.location(309,9); |
| match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration167); if (state.failed) return ; |
| dbg.location(309,19); |
| pushFollow(FOLLOW_qualifiedName_in_packageDeclaration169); |
| qualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(310,9); |
| match(input,SEMI,FOLLOW_SEMI_in_packageDeclaration179); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 2, packageDeclaration_StartIndex); } |
| } |
| dbg.location(311, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "packageDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "packageDeclaration" |
| |
| |
| // $ANTLR start "importDeclaration" |
| // src/com/google/doclava/parser/Java.g:313:1: importDeclaration : ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' ); |
| public final void importDeclaration() throws RecognitionException { |
| int importDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "importDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(313, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:314:5: ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' ) |
| int alt9=2; |
| try { dbg.enterDecision(9, decisionCanBacktrack[9]); |
| |
| int LA9_0 = input.LA(1); |
| |
| if ( (LA9_0==IMPORT) ) { |
| int LA9_1 = input.LA(2); |
| |
| if ( (LA9_1==STATIC) ) { |
| int LA9_2 = input.LA(3); |
| |
| if ( (LA9_2==IDENTIFIER) ) { |
| int LA9_3 = input.LA(4); |
| |
| if ( (LA9_3==DOT) ) { |
| int LA9_4 = input.LA(5); |
| |
| if ( (LA9_4==STAR) ) { |
| alt9=1; |
| } |
| else if ( (LA9_4==IDENTIFIER) ) { |
| alt9=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 4, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 3, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 2, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else if ( (LA9_1==IDENTIFIER) ) { |
| int LA9_3 = input.LA(3); |
| |
| if ( (LA9_3==DOT) ) { |
| int LA9_4 = input.LA(4); |
| |
| if ( (LA9_4==STAR) ) { |
| alt9=1; |
| } |
| else if ( (LA9_4==IDENTIFIER) ) { |
| alt9=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 4, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 3, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 9, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(9);} |
| |
| switch (alt9) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:314:9: 'import' ( 'static' )? IDENTIFIER '.' '*' ';' |
| { |
| dbg.location(314,9); |
| match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration198); if (state.failed) return ; |
| dbg.location(315,9); |
| // src/com/google/doclava/parser/Java.g:315:9: ( 'static' )? |
| int alt5=2; |
| try { dbg.enterSubRule(5); |
| try { dbg.enterDecision(5, decisionCanBacktrack[5]); |
| |
| int LA5_0 = input.LA(1); |
| |
| if ( (LA5_0==STATIC) ) { |
| alt5=1; |
| } |
| } finally {dbg.exitDecision(5);} |
| |
| switch (alt5) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:315:10: 'static' |
| { |
| dbg.location(315,10); |
| match(input,STATIC,FOLLOW_STATIC_in_importDeclaration209); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(5);} |
| |
| dbg.location(317,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration230); if (state.failed) return ; |
| dbg.location(317,20); |
| match(input,DOT,FOLLOW_DOT_in_importDeclaration232); if (state.failed) return ; |
| dbg.location(317,24); |
| match(input,STAR,FOLLOW_STAR_in_importDeclaration234); if (state.failed) return ; |
| dbg.location(318,9); |
| match(input,SEMI,FOLLOW_SEMI_in_importDeclaration244); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:319:9: 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' |
| { |
| dbg.location(319,9); |
| match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration254); if (state.failed) return ; |
| dbg.location(320,9); |
| // src/com/google/doclava/parser/Java.g:320:9: ( 'static' )? |
| int alt6=2; |
| try { dbg.enterSubRule(6); |
| try { dbg.enterDecision(6, decisionCanBacktrack[6]); |
| |
| int LA6_0 = input.LA(1); |
| |
| if ( (LA6_0==STATIC) ) { |
| alt6=1; |
| } |
| } finally {dbg.exitDecision(6);} |
| |
| switch (alt6) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:320:10: 'static' |
| { |
| dbg.location(320,10); |
| match(input,STATIC,FOLLOW_STATIC_in_importDeclaration265); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(6);} |
| |
| dbg.location(322,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration286); if (state.failed) return ; |
| dbg.location(323,9); |
| // src/com/google/doclava/parser/Java.g:323:9: ( '.' IDENTIFIER )+ |
| int cnt7=0; |
| try { dbg.enterSubRule(7); |
| |
| loop7: |
| do { |
| int alt7=2; |
| try { dbg.enterDecision(7, decisionCanBacktrack[7]); |
| |
| int LA7_0 = input.LA(1); |
| |
| if ( (LA7_0==DOT) ) { |
| int LA7_1 = input.LA(2); |
| |
| if ( (LA7_1==IDENTIFIER) ) { |
| alt7=1; |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(7);} |
| |
| switch (alt7) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:323:10: '.' IDENTIFIER |
| { |
| dbg.location(323,10); |
| match(input,DOT,FOLLOW_DOT_in_importDeclaration297); if (state.failed) return ; |
| dbg.location(323,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration299); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| if ( cnt7 >= 1 ) break loop7; |
| if (state.backtracking>0) {state.failed=true; return ;} |
| EarlyExitException eee = |
| new EarlyExitException(7, input); |
| dbg.recognitionException(eee); |
| |
| throw eee; |
| } |
| cnt7++; |
| } while (true); |
| } finally {dbg.exitSubRule(7);} |
| |
| dbg.location(325,9); |
| // src/com/google/doclava/parser/Java.g:325:9: ( '.' '*' )? |
| int alt8=2; |
| try { dbg.enterSubRule(8); |
| try { dbg.enterDecision(8, decisionCanBacktrack[8]); |
| |
| int LA8_0 = input.LA(1); |
| |
| if ( (LA8_0==DOT) ) { |
| alt8=1; |
| } |
| } finally {dbg.exitDecision(8);} |
| |
| switch (alt8) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:325:10: '.' '*' |
| { |
| dbg.location(325,10); |
| match(input,DOT,FOLLOW_DOT_in_importDeclaration321); if (state.failed) return ; |
| dbg.location(325,14); |
| match(input,STAR,FOLLOW_STAR_in_importDeclaration323); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(8);} |
| |
| dbg.location(327,9); |
| match(input,SEMI,FOLLOW_SEMI_in_importDeclaration344); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 3, importDeclaration_StartIndex); } |
| } |
| dbg.location(328, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "importDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "importDeclaration" |
| |
| |
| // $ANTLR start "qualifiedImportName" |
| // src/com/google/doclava/parser/Java.g:330:1: qualifiedImportName : IDENTIFIER ( '.' IDENTIFIER )* ; |
| public final void qualifiedImportName() throws RecognitionException { |
| int qualifiedImportName_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "qualifiedImportName"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(330, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:331:5: ( IDENTIFIER ( '.' IDENTIFIER )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:331:9: IDENTIFIER ( '.' IDENTIFIER )* |
| { |
| dbg.location(331,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName363); if (state.failed) return ; |
| dbg.location(332,9); |
| // src/com/google/doclava/parser/Java.g:332:9: ( '.' IDENTIFIER )* |
| try { dbg.enterSubRule(10); |
| |
| loop10: |
| do { |
| int alt10=2; |
| try { dbg.enterDecision(10, decisionCanBacktrack[10]); |
| |
| int LA10_0 = input.LA(1); |
| |
| if ( (LA10_0==DOT) ) { |
| alt10=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(10);} |
| |
| switch (alt10) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:332:10: '.' IDENTIFIER |
| { |
| dbg.location(332,10); |
| match(input,DOT,FOLLOW_DOT_in_qualifiedImportName374); if (state.failed) return ; |
| dbg.location(332,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName376); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop10; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(10);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 4, qualifiedImportName_StartIndex); } |
| } |
| dbg.location(334, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "qualifiedImportName"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "qualifiedImportName" |
| |
| |
| // $ANTLR start "typeDeclaration" |
| // src/com/google/doclava/parser/Java.g:336:1: typeDeclaration : ( classOrInterfaceDeclaration | ';' ); |
| public final void typeDeclaration() throws RecognitionException { |
| int typeDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(336, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:337:5: ( classOrInterfaceDeclaration | ';' ) |
| int alt11=2; |
| try { dbg.enterDecision(11, decisionCanBacktrack[11]); |
| |
| int LA11_0 = input.LA(1); |
| |
| if ( (LA11_0==IDENTIFIER||LA11_0==ABSTRACT||LA11_0==BOOLEAN||LA11_0==BYTE||(LA11_0>=CHAR && LA11_0<=CLASS)||LA11_0==DOUBLE||LA11_0==ENUM||LA11_0==FINAL||LA11_0==FLOAT||(LA11_0>=INT && LA11_0<=NATIVE)||(LA11_0>=PRIVATE && LA11_0<=PUBLIC)||(LA11_0>=SHORT && LA11_0<=STRICTFP)||LA11_0==SYNCHRONIZED||LA11_0==TRANSIENT||(LA11_0>=VOID && LA11_0<=VOLATILE)||LA11_0==MONKEYS_AT||LA11_0==LT) ) { |
| alt11=1; |
| } |
| else if ( (LA11_0==SEMI) ) { |
| alt11=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 11, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(11);} |
| |
| switch (alt11) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:337:9: classOrInterfaceDeclaration |
| { |
| dbg.location(337,9); |
| pushFollow(FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406); |
| classOrInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:338:9: ';' |
| { |
| dbg.location(338,9); |
| match(input,SEMI,FOLLOW_SEMI_in_typeDeclaration416); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 5, typeDeclaration_StartIndex); } |
| } |
| dbg.location(339, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeDeclaration" |
| |
| |
| // $ANTLR start "classOrInterfaceDeclaration" |
| // src/com/google/doclava/parser/Java.g:341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration ); |
| public final void classOrInterfaceDeclaration() throws RecognitionException { |
| int classOrInterfaceDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(341, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:342:5: ( classDeclaration | interfaceDeclaration ) |
| int alt12=2; |
| try { dbg.enterDecision(12, decisionCanBacktrack[12]); |
| |
| try { |
| isCyclicDecision = true; |
| alt12 = dfa12.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(12);} |
| |
| switch (alt12) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:342:10: classDeclaration |
| { |
| dbg.location(342,10); |
| pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436); |
| classDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:343:9: interfaceDeclaration |
| { |
| dbg.location(343,9); |
| pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446); |
| interfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 6, classOrInterfaceDeclaration_StartIndex); } |
| } |
| dbg.location(344, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classOrInterfaceDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classOrInterfaceDeclaration" |
| |
| |
| // $ANTLR start "modifiers" |
| // src/com/google/doclava/parser/Java.g:347:1: modifiers : ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ; |
| public final void modifiers() throws RecognitionException { |
| int modifiers_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "modifiers"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(347, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:348:5: ( ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* |
| { |
| dbg.location(349,5); |
| // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* |
| try { dbg.enterSubRule(13); |
| |
| loop13: |
| do { |
| int alt13=13; |
| try { dbg.enterDecision(13, decisionCanBacktrack[13]); |
| |
| try { |
| isCyclicDecision = true; |
| alt13 = dfa13.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(13);} |
| |
| switch (alt13) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:349:10: annotation |
| { |
| dbg.location(349,10); |
| pushFollow(FOLLOW_annotation_in_modifiers473); |
| annotation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:350:9: 'public' |
| { |
| dbg.location(350,9); |
| match(input,PUBLIC,FOLLOW_PUBLIC_in_modifiers483); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:351:9: 'protected' |
| { |
| dbg.location(351,9); |
| match(input,PROTECTED,FOLLOW_PROTECTED_in_modifiers493); if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:352:9: 'private' |
| { |
| dbg.location(352,9); |
| match(input,PRIVATE,FOLLOW_PRIVATE_in_modifiers503); if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:353:9: 'static' |
| { |
| dbg.location(353,9); |
| match(input,STATIC,FOLLOW_STATIC_in_modifiers513); if (state.failed) return ; |
| |
| } |
| break; |
| case 6 : |
| dbg.enterAlt(6); |
| |
| // src/com/google/doclava/parser/Java.g:354:9: 'abstract' |
| { |
| dbg.location(354,9); |
| match(input,ABSTRACT,FOLLOW_ABSTRACT_in_modifiers523); if (state.failed) return ; |
| |
| } |
| break; |
| case 7 : |
| dbg.enterAlt(7); |
| |
| // src/com/google/doclava/parser/Java.g:355:9: 'final' |
| { |
| dbg.location(355,9); |
| match(input,FINAL,FOLLOW_FINAL_in_modifiers533); if (state.failed) return ; |
| |
| } |
| break; |
| case 8 : |
| dbg.enterAlt(8); |
| |
| // src/com/google/doclava/parser/Java.g:356:9: 'native' |
| { |
| dbg.location(356,9); |
| match(input,NATIVE,FOLLOW_NATIVE_in_modifiers543); if (state.failed) return ; |
| |
| } |
| break; |
| case 9 : |
| dbg.enterAlt(9); |
| |
| // src/com/google/doclava/parser/Java.g:357:9: 'synchronized' |
| { |
| dbg.location(357,9); |
| match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_modifiers553); if (state.failed) return ; |
| |
| } |
| break; |
| case 10 : |
| dbg.enterAlt(10); |
| |
| // src/com/google/doclava/parser/Java.g:358:9: 'transient' |
| { |
| dbg.location(358,9); |
| match(input,TRANSIENT,FOLLOW_TRANSIENT_in_modifiers563); if (state.failed) return ; |
| |
| } |
| break; |
| case 11 : |
| dbg.enterAlt(11); |
| |
| // src/com/google/doclava/parser/Java.g:359:9: 'volatile' |
| { |
| dbg.location(359,9); |
| match(input,VOLATILE,FOLLOW_VOLATILE_in_modifiers573); if (state.failed) return ; |
| |
| } |
| break; |
| case 12 : |
| dbg.enterAlt(12); |
| |
| // src/com/google/doclava/parser/Java.g:360:9: 'strictfp' |
| { |
| dbg.location(360,9); |
| match(input,STRICTFP,FOLLOW_STRICTFP_in_modifiers583); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop13; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(13);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 7, modifiers_StartIndex); } |
| } |
| dbg.location(362, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "modifiers"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "modifiers" |
| |
| |
| // $ANTLR start "variableModifiers" |
| // src/com/google/doclava/parser/Java.g:365:1: variableModifiers : ( 'final' | annotation )* ; |
| public final void variableModifiers() throws RecognitionException { |
| int variableModifiers_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "variableModifiers"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(365, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:366:5: ( ( 'final' | annotation )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )* |
| { |
| dbg.location(366,9); |
| // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )* |
| try { dbg.enterSubRule(14); |
| |
| loop14: |
| do { |
| int alt14=3; |
| try { dbg.enterDecision(14, decisionCanBacktrack[14]); |
| |
| int LA14_0 = input.LA(1); |
| |
| if ( (LA14_0==FINAL) ) { |
| alt14=1; |
| } |
| else if ( (LA14_0==MONKEYS_AT) ) { |
| alt14=2; |
| } |
| |
| |
| } finally {dbg.exitDecision(14);} |
| |
| switch (alt14) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:366:13: 'final' |
| { |
| dbg.location(366,13); |
| match(input,FINAL,FOLLOW_FINAL_in_variableModifiers614); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:367:13: annotation |
| { |
| dbg.location(367,13); |
| pushFollow(FOLLOW_annotation_in_variableModifiers628); |
| annotation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop14; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(14);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 8, variableModifiers_StartIndex); } |
| } |
| dbg.location(369, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "variableModifiers"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "variableModifiers" |
| |
| |
| // $ANTLR start "classDeclaration" |
| // src/com/google/doclava/parser/Java.g:372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration ); |
| public final void classDeclaration() throws RecognitionException { |
| int classDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(372, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:373:5: ( normalClassDeclaration | enumDeclaration ) |
| int alt15=2; |
| try { dbg.enterDecision(15, decisionCanBacktrack[15]); |
| |
| try { |
| isCyclicDecision = true; |
| alt15 = dfa15.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(15);} |
| |
| switch (alt15) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration |
| { |
| dbg.location(373,9); |
| pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration659); |
| normalClassDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:374:9: enumDeclaration |
| { |
| dbg.location(374,9); |
| pushFollow(FOLLOW_enumDeclaration_in_classDeclaration669); |
| enumDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 9, classDeclaration_StartIndex); } |
| } |
| dbg.location(375, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classDeclaration" |
| |
| |
| // $ANTLR start "normalClassDeclaration" |
| // src/com/google/doclava/parser/Java.g:377:1: normalClassDeclaration : modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody ; |
| public final void normalClassDeclaration() throws RecognitionException { |
| int normalClassDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "normalClassDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(377, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:378:5: ( modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:378:9: modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody |
| { |
| dbg.location(378,9); |
| pushFollow(FOLLOW_modifiers_in_normalClassDeclaration688); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(378,20); |
| match(input,CLASS,FOLLOW_CLASS_in_normalClassDeclaration691); if (state.failed) return ; |
| dbg.location(378,28); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalClassDeclaration693); if (state.failed) return ; |
| dbg.location(379,9); |
| // src/com/google/doclava/parser/Java.g:379:9: ( typeParameters )? |
| int alt16=2; |
| try { dbg.enterSubRule(16); |
| try { dbg.enterDecision(16, decisionCanBacktrack[16]); |
| |
| int LA16_0 = input.LA(1); |
| |
| if ( (LA16_0==LT) ) { |
| alt16=1; |
| } |
| } finally {dbg.exitDecision(16);} |
| |
| switch (alt16) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:379:10: typeParameters |
| { |
| dbg.location(379,10); |
| pushFollow(FOLLOW_typeParameters_in_normalClassDeclaration704); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(16);} |
| |
| dbg.location(381,9); |
| // src/com/google/doclava/parser/Java.g:381:9: ( 'extends' type )? |
| int alt17=2; |
| try { dbg.enterSubRule(17); |
| try { dbg.enterDecision(17, decisionCanBacktrack[17]); |
| |
| int LA17_0 = input.LA(1); |
| |
| if ( (LA17_0==EXTENDS) ) { |
| alt17=1; |
| } |
| } finally {dbg.exitDecision(17);} |
| |
| switch (alt17) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:381:10: 'extends' type |
| { |
| dbg.location(381,10); |
| match(input,EXTENDS,FOLLOW_EXTENDS_in_normalClassDeclaration726); if (state.failed) return ; |
| dbg.location(381,20); |
| pushFollow(FOLLOW_type_in_normalClassDeclaration728); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(17);} |
| |
| dbg.location(383,9); |
| // src/com/google/doclava/parser/Java.g:383:9: ( 'implements' typeList )? |
| int alt18=2; |
| try { dbg.enterSubRule(18); |
| try { dbg.enterDecision(18, decisionCanBacktrack[18]); |
| |
| int LA18_0 = input.LA(1); |
| |
| if ( (LA18_0==IMPLEMENTS) ) { |
| alt18=1; |
| } |
| } finally {dbg.exitDecision(18);} |
| |
| switch (alt18) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:383:10: 'implements' typeList |
| { |
| dbg.location(383,10); |
| match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_normalClassDeclaration750); if (state.failed) return ; |
| dbg.location(383,23); |
| pushFollow(FOLLOW_typeList_in_normalClassDeclaration752); |
| typeList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(18);} |
| |
| dbg.location(385,9); |
| pushFollow(FOLLOW_classBody_in_normalClassDeclaration773); |
| classBody(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 10, normalClassDeclaration_StartIndex); } |
| } |
| dbg.location(386, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "normalClassDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "normalClassDeclaration" |
| |
| |
| // $ANTLR start "typeParameters" |
| // src/com/google/doclava/parser/Java.g:389:1: typeParameters : '<' typeParameter ( ',' typeParameter )* '>' ; |
| public final void typeParameters() throws RecognitionException { |
| int typeParameters_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeParameters"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(389, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:390:5: ( '<' typeParameter ( ',' typeParameter )* '>' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:390:9: '<' typeParameter ( ',' typeParameter )* '>' |
| { |
| dbg.location(390,9); |
| match(input,LT,FOLLOW_LT_in_typeParameters793); if (state.failed) return ; |
| dbg.location(391,13); |
| pushFollow(FOLLOW_typeParameter_in_typeParameters807); |
| typeParameter(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(392,13); |
| // src/com/google/doclava/parser/Java.g:392:13: ( ',' typeParameter )* |
| try { dbg.enterSubRule(19); |
| |
| loop19: |
| do { |
| int alt19=2; |
| try { dbg.enterDecision(19, decisionCanBacktrack[19]); |
| |
| int LA19_0 = input.LA(1); |
| |
| if ( (LA19_0==COMMA) ) { |
| alt19=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(19);} |
| |
| switch (alt19) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:392:14: ',' typeParameter |
| { |
| dbg.location(392,14); |
| match(input,COMMA,FOLLOW_COMMA_in_typeParameters822); if (state.failed) return ; |
| dbg.location(392,18); |
| pushFollow(FOLLOW_typeParameter_in_typeParameters824); |
| typeParameter(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop19; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(19);} |
| |
| dbg.location(394,9); |
| match(input,GT,FOLLOW_GT_in_typeParameters849); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 11, typeParameters_StartIndex); } |
| } |
| dbg.location(395, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeParameters"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeParameters" |
| |
| |
| // $ANTLR start "typeParameter" |
| // src/com/google/doclava/parser/Java.g:397:1: typeParameter : IDENTIFIER ( 'extends' typeBound )? ; |
| public final void typeParameter() throws RecognitionException { |
| int typeParameter_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeParameter"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(397, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:398:5: ( IDENTIFIER ( 'extends' typeBound )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:398:9: IDENTIFIER ( 'extends' typeBound )? |
| { |
| dbg.location(398,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeParameter868); if (state.failed) return ; |
| dbg.location(399,9); |
| // src/com/google/doclava/parser/Java.g:399:9: ( 'extends' typeBound )? |
| int alt20=2; |
| try { dbg.enterSubRule(20); |
| try { dbg.enterDecision(20, decisionCanBacktrack[20]); |
| |
| int LA20_0 = input.LA(1); |
| |
| if ( (LA20_0==EXTENDS) ) { |
| alt20=1; |
| } |
| } finally {dbg.exitDecision(20);} |
| |
| switch (alt20) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:399:10: 'extends' typeBound |
| { |
| dbg.location(399,10); |
| match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameter879); if (state.failed) return ; |
| dbg.location(399,20); |
| pushFollow(FOLLOW_typeBound_in_typeParameter881); |
| typeBound(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(20);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 12, typeParameter_StartIndex); } |
| } |
| dbg.location(401, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeParameter"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeParameter" |
| |
| |
| // $ANTLR start "typeBound" |
| // src/com/google/doclava/parser/Java.g:404:1: typeBound : type ( '&' type )* ; |
| public final void typeBound() throws RecognitionException { |
| int typeBound_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeBound"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(404, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:405:5: ( type ( '&' type )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:405:9: type ( '&' type )* |
| { |
| dbg.location(405,9); |
| pushFollow(FOLLOW_type_in_typeBound912); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(406,9); |
| // src/com/google/doclava/parser/Java.g:406:9: ( '&' type )* |
| try { dbg.enterSubRule(21); |
| |
| loop21: |
| do { |
| int alt21=2; |
| try { dbg.enterDecision(21, decisionCanBacktrack[21]); |
| |
| int LA21_0 = input.LA(1); |
| |
| if ( (LA21_0==AMP) ) { |
| alt21=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(21);} |
| |
| switch (alt21) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:406:10: '&' type |
| { |
| dbg.location(406,10); |
| match(input,AMP,FOLLOW_AMP_in_typeBound923); if (state.failed) return ; |
| dbg.location(406,14); |
| pushFollow(FOLLOW_type_in_typeBound925); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop21; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(21);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 13, typeBound_StartIndex); } |
| } |
| dbg.location(408, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeBound"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeBound" |
| |
| |
| // $ANTLR start "enumDeclaration" |
| // src/com/google/doclava/parser/Java.g:411:1: enumDeclaration : modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody ; |
| public final void enumDeclaration() throws RecognitionException { |
| int enumDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "enumDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(411, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:412:5: ( modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:412:9: modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody |
| { |
| dbg.location(412,9); |
| pushFollow(FOLLOW_modifiers_in_enumDeclaration956); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(413,9); |
| // src/com/google/doclava/parser/Java.g:413:9: ( 'enum' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:413:10: 'enum' |
| { |
| dbg.location(413,10); |
| match(input,ENUM,FOLLOW_ENUM_in_enumDeclaration967); if (state.failed) return ; |
| |
| } |
| |
| dbg.location(415,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumDeclaration987); if (state.failed) return ; |
| dbg.location(416,9); |
| // src/com/google/doclava/parser/Java.g:416:9: ( 'implements' typeList )? |
| int alt22=2; |
| try { dbg.enterSubRule(22); |
| try { dbg.enterDecision(22, decisionCanBacktrack[22]); |
| |
| int LA22_0 = input.LA(1); |
| |
| if ( (LA22_0==IMPLEMENTS) ) { |
| alt22=1; |
| } |
| } finally {dbg.exitDecision(22);} |
| |
| switch (alt22) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:416:10: 'implements' typeList |
| { |
| dbg.location(416,10); |
| match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_enumDeclaration998); if (state.failed) return ; |
| dbg.location(416,23); |
| pushFollow(FOLLOW_typeList_in_enumDeclaration1000); |
| typeList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(22);} |
| |
| dbg.location(418,9); |
| pushFollow(FOLLOW_enumBody_in_enumDeclaration1021); |
| enumBody(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 14, enumDeclaration_StartIndex); } |
| } |
| dbg.location(419, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "enumDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "enumDeclaration" |
| |
| |
| // $ANTLR start "enumBody" |
| // src/com/google/doclava/parser/Java.g:422:1: enumBody : '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' ; |
| public final void enumBody() throws RecognitionException { |
| int enumBody_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "enumBody"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(422, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:423:5: ( '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:423:9: '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' |
| { |
| dbg.location(423,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_enumBody1041); if (state.failed) return ; |
| dbg.location(424,9); |
| // src/com/google/doclava/parser/Java.g:424:9: ( enumConstants )? |
| int alt23=2; |
| try { dbg.enterSubRule(23); |
| try { dbg.enterDecision(23, decisionCanBacktrack[23]); |
| |
| int LA23_0 = input.LA(1); |
| |
| if ( (LA23_0==IDENTIFIER||LA23_0==MONKEYS_AT) ) { |
| alt23=1; |
| } |
| } finally {dbg.exitDecision(23);} |
| |
| switch (alt23) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:424:10: enumConstants |
| { |
| dbg.location(424,10); |
| pushFollow(FOLLOW_enumConstants_in_enumBody1052); |
| enumConstants(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(23);} |
| |
| dbg.location(426,9); |
| // src/com/google/doclava/parser/Java.g:426:9: ( ',' )? |
| int alt24=2; |
| try { dbg.enterSubRule(24); |
| try { dbg.enterDecision(24, decisionCanBacktrack[24]); |
| |
| int LA24_0 = input.LA(1); |
| |
| if ( (LA24_0==COMMA) ) { |
| alt24=1; |
| } |
| } finally {dbg.exitDecision(24);} |
| |
| switch (alt24) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:0:0: ',' |
| { |
| dbg.location(426,9); |
| match(input,COMMA,FOLLOW_COMMA_in_enumBody1073); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(24);} |
| |
| dbg.location(427,9); |
| // src/com/google/doclava/parser/Java.g:427:9: ( enumBodyDeclarations )? |
| int alt25=2; |
| try { dbg.enterSubRule(25); |
| try { dbg.enterDecision(25, decisionCanBacktrack[25]); |
| |
| int LA25_0 = input.LA(1); |
| |
| if ( (LA25_0==SEMI) ) { |
| alt25=1; |
| } |
| } finally {dbg.exitDecision(25);} |
| |
| switch (alt25) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:427:10: enumBodyDeclarations |
| { |
| dbg.location(427,10); |
| pushFollow(FOLLOW_enumBodyDeclarations_in_enumBody1085); |
| enumBodyDeclarations(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(25);} |
| |
| dbg.location(429,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_enumBody1106); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 15, enumBody_StartIndex); } |
| } |
| dbg.location(430, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "enumBody"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "enumBody" |
| |
| |
| // $ANTLR start "enumConstants" |
| // src/com/google/doclava/parser/Java.g:432:1: enumConstants : enumConstant ( ',' enumConstant )* ; |
| public final void enumConstants() throws RecognitionException { |
| int enumConstants_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "enumConstants"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(432, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:433:5: ( enumConstant ( ',' enumConstant )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:433:9: enumConstant ( ',' enumConstant )* |
| { |
| dbg.location(433,9); |
| pushFollow(FOLLOW_enumConstant_in_enumConstants1125); |
| enumConstant(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(434,9); |
| // src/com/google/doclava/parser/Java.g:434:9: ( ',' enumConstant )* |
| try { dbg.enterSubRule(26); |
| |
| loop26: |
| do { |
| int alt26=2; |
| try { dbg.enterDecision(26, decisionCanBacktrack[26]); |
| |
| int LA26_0 = input.LA(1); |
| |
| if ( (LA26_0==COMMA) ) { |
| int LA26_1 = input.LA(2); |
| |
| if ( (LA26_1==IDENTIFIER||LA26_1==MONKEYS_AT) ) { |
| alt26=1; |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(26);} |
| |
| switch (alt26) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:434:10: ',' enumConstant |
| { |
| dbg.location(434,10); |
| match(input,COMMA,FOLLOW_COMMA_in_enumConstants1136); if (state.failed) return ; |
| dbg.location(434,14); |
| pushFollow(FOLLOW_enumConstant_in_enumConstants1138); |
| enumConstant(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop26; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(26);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 16, enumConstants_StartIndex); } |
| } |
| dbg.location(436, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "enumConstants"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "enumConstants" |
| |
| |
| // $ANTLR start "enumConstant" |
| // src/com/google/doclava/parser/Java.g:438:1: enumConstant : ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ; |
| public final void enumConstant() throws RecognitionException { |
| int enumConstant_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "enumConstant"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(438, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:443:5: ( ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:443:9: ( annotations )? IDENTIFIER ( arguments )? ( classBody )? |
| { |
| dbg.location(443,9); |
| // src/com/google/doclava/parser/Java.g:443:9: ( annotations )? |
| int alt27=2; |
| try { dbg.enterSubRule(27); |
| try { dbg.enterDecision(27, decisionCanBacktrack[27]); |
| |
| int LA27_0 = input.LA(1); |
| |
| if ( (LA27_0==MONKEYS_AT) ) { |
| alt27=1; |
| } |
| } finally {dbg.exitDecision(27);} |
| |
| switch (alt27) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:443:10: annotations |
| { |
| dbg.location(443,10); |
| pushFollow(FOLLOW_annotations_in_enumConstant1171); |
| annotations(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(27);} |
| |
| dbg.location(445,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant1192); if (state.failed) return ; |
| dbg.location(446,9); |
| // src/com/google/doclava/parser/Java.g:446:9: ( arguments )? |
| int alt28=2; |
| try { dbg.enterSubRule(28); |
| try { dbg.enterDecision(28, decisionCanBacktrack[28]); |
| |
| int LA28_0 = input.LA(1); |
| |
| if ( (LA28_0==LPAREN) ) { |
| alt28=1; |
| } |
| } finally {dbg.exitDecision(28);} |
| |
| switch (alt28) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:446:10: arguments |
| { |
| dbg.location(446,10); |
| pushFollow(FOLLOW_arguments_in_enumConstant1203); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(28);} |
| |
| dbg.location(448,9); |
| // src/com/google/doclava/parser/Java.g:448:9: ( classBody )? |
| int alt29=2; |
| try { dbg.enterSubRule(29); |
| try { dbg.enterDecision(29, decisionCanBacktrack[29]); |
| |
| int LA29_0 = input.LA(1); |
| |
| if ( (LA29_0==LBRACE) ) { |
| alt29=1; |
| } |
| } finally {dbg.exitDecision(29);} |
| |
| switch (alt29) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:448:10: classBody |
| { |
| dbg.location(448,10); |
| pushFollow(FOLLOW_classBody_in_enumConstant1225); |
| classBody(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(29);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 17, enumConstant_StartIndex); } |
| } |
| dbg.location(452, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "enumConstant"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "enumConstant" |
| |
| |
| // $ANTLR start "enumBodyDeclarations" |
| // src/com/google/doclava/parser/Java.g:454:1: enumBodyDeclarations : ';' ( classBodyDeclaration )* ; |
| public final void enumBodyDeclarations() throws RecognitionException { |
| int enumBodyDeclarations_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "enumBodyDeclarations"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(454, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:455:5: ( ';' ( classBodyDeclaration )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:455:9: ';' ( classBodyDeclaration )* |
| { |
| dbg.location(455,9); |
| match(input,SEMI,FOLLOW_SEMI_in_enumBodyDeclarations1265); if (state.failed) return ; |
| dbg.location(456,9); |
| // src/com/google/doclava/parser/Java.g:456:9: ( classBodyDeclaration )* |
| try { dbg.enterSubRule(30); |
| |
| loop30: |
| do { |
| int alt30=2; |
| try { dbg.enterDecision(30, decisionCanBacktrack[30]); |
| |
| int LA30_0 = input.LA(1); |
| |
| if ( (LA30_0==IDENTIFIER||LA30_0==ABSTRACT||LA30_0==BOOLEAN||LA30_0==BYTE||(LA30_0>=CHAR && LA30_0<=CLASS)||LA30_0==DOUBLE||LA30_0==ENUM||LA30_0==FINAL||LA30_0==FLOAT||(LA30_0>=INT && LA30_0<=NATIVE)||(LA30_0>=PRIVATE && LA30_0<=PUBLIC)||(LA30_0>=SHORT && LA30_0<=STRICTFP)||LA30_0==SYNCHRONIZED||LA30_0==TRANSIENT||(LA30_0>=VOID && LA30_0<=VOLATILE)||LA30_0==LBRACE||LA30_0==SEMI||LA30_0==MONKEYS_AT||LA30_0==LT) ) { |
| alt30=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(30);} |
| |
| switch (alt30) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:456:10: classBodyDeclaration |
| { |
| dbg.location(456,10); |
| pushFollow(FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276); |
| classBodyDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop30; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(30);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 18, enumBodyDeclarations_StartIndex); } |
| } |
| dbg.location(458, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "enumBodyDeclarations"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "enumBodyDeclarations" |
| |
| |
| // $ANTLR start "interfaceDeclaration" |
| // src/com/google/doclava/parser/Java.g:460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration ); |
| public final void interfaceDeclaration() throws RecognitionException { |
| int interfaceDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "interfaceDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(460, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:461:5: ( normalInterfaceDeclaration | annotationTypeDeclaration ) |
| int alt31=2; |
| try { dbg.enterDecision(31, decisionCanBacktrack[31]); |
| |
| try { |
| isCyclicDecision = true; |
| alt31 = dfa31.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(31);} |
| |
| switch (alt31) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration |
| { |
| dbg.location(461,9); |
| pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306); |
| normalInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:462:9: annotationTypeDeclaration |
| { |
| dbg.location(462,9); |
| pushFollow(FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316); |
| annotationTypeDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 19, interfaceDeclaration_StartIndex); } |
| } |
| dbg.location(463, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "interfaceDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "interfaceDeclaration" |
| |
| |
| // $ANTLR start "normalInterfaceDeclaration" |
| // src/com/google/doclava/parser/Java.g:465:1: normalInterfaceDeclaration : modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody ; |
| public final void normalInterfaceDeclaration() throws RecognitionException { |
| int normalInterfaceDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "normalInterfaceDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(465, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:466:5: ( modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:466:9: modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody |
| { |
| dbg.location(466,9); |
| pushFollow(FOLLOW_modifiers_in_normalInterfaceDeclaration1335); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(466,19); |
| match(input,INTERFACE,FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337); if (state.failed) return ; |
| dbg.location(466,31); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339); if (state.failed) return ; |
| dbg.location(467,9); |
| // src/com/google/doclava/parser/Java.g:467:9: ( typeParameters )? |
| int alt32=2; |
| try { dbg.enterSubRule(32); |
| try { dbg.enterDecision(32, decisionCanBacktrack[32]); |
| |
| int LA32_0 = input.LA(1); |
| |
| if ( (LA32_0==LT) ) { |
| alt32=1; |
| } |
| } finally {dbg.exitDecision(32);} |
| |
| switch (alt32) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:467:10: typeParameters |
| { |
| dbg.location(467,10); |
| pushFollow(FOLLOW_typeParameters_in_normalInterfaceDeclaration1350); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(32);} |
| |
| dbg.location(469,9); |
| // src/com/google/doclava/parser/Java.g:469:9: ( 'extends' typeList )? |
| int alt33=2; |
| try { dbg.enterSubRule(33); |
| try { dbg.enterDecision(33, decisionCanBacktrack[33]); |
| |
| int LA33_0 = input.LA(1); |
| |
| if ( (LA33_0==EXTENDS) ) { |
| alt33=1; |
| } |
| } finally {dbg.exitDecision(33);} |
| |
| switch (alt33) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:469:10: 'extends' typeList |
| { |
| dbg.location(469,10); |
| match(input,EXTENDS,FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372); if (state.failed) return ; |
| dbg.location(469,20); |
| pushFollow(FOLLOW_typeList_in_normalInterfaceDeclaration1374); |
| typeList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(33);} |
| |
| dbg.location(471,9); |
| pushFollow(FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395); |
| interfaceBody(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 20, normalInterfaceDeclaration_StartIndex); } |
| } |
| dbg.location(472, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "normalInterfaceDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "normalInterfaceDeclaration" |
| |
| |
| // $ANTLR start "typeList" |
| // src/com/google/doclava/parser/Java.g:474:1: typeList : type ( ',' type )* ; |
| public final void typeList() throws RecognitionException { |
| int typeList_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeList"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(474, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:475:5: ( type ( ',' type )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:475:9: type ( ',' type )* |
| { |
| dbg.location(475,9); |
| pushFollow(FOLLOW_type_in_typeList1414); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(476,9); |
| // src/com/google/doclava/parser/Java.g:476:9: ( ',' type )* |
| try { dbg.enterSubRule(34); |
| |
| loop34: |
| do { |
| int alt34=2; |
| try { dbg.enterDecision(34, decisionCanBacktrack[34]); |
| |
| int LA34_0 = input.LA(1); |
| |
| if ( (LA34_0==COMMA) ) { |
| alt34=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(34);} |
| |
| switch (alt34) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:476:10: ',' type |
| { |
| dbg.location(476,10); |
| match(input,COMMA,FOLLOW_COMMA_in_typeList1425); if (state.failed) return ; |
| dbg.location(476,14); |
| pushFollow(FOLLOW_type_in_typeList1427); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop34; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(34);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 21, typeList_StartIndex); } |
| } |
| dbg.location(478, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeList"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeList" |
| |
| |
| // $ANTLR start "classBody" |
| // src/com/google/doclava/parser/Java.g:480:1: classBody : '{' ( classBodyDeclaration )* '}' ; |
| public final void classBody() throws RecognitionException { |
| int classBody_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classBody"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(480, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:481:5: ( '{' ( classBodyDeclaration )* '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:481:9: '{' ( classBodyDeclaration )* '}' |
| { |
| dbg.location(481,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_classBody1457); if (state.failed) return ; |
| dbg.location(482,9); |
| // src/com/google/doclava/parser/Java.g:482:9: ( classBodyDeclaration )* |
| try { dbg.enterSubRule(35); |
| |
| loop35: |
| do { |
| int alt35=2; |
| try { dbg.enterDecision(35, decisionCanBacktrack[35]); |
| |
| int LA35_0 = input.LA(1); |
| |
| if ( (LA35_0==IDENTIFIER||LA35_0==ABSTRACT||LA35_0==BOOLEAN||LA35_0==BYTE||(LA35_0>=CHAR && LA35_0<=CLASS)||LA35_0==DOUBLE||LA35_0==ENUM||LA35_0==FINAL||LA35_0==FLOAT||(LA35_0>=INT && LA35_0<=NATIVE)||(LA35_0>=PRIVATE && LA35_0<=PUBLIC)||(LA35_0>=SHORT && LA35_0<=STRICTFP)||LA35_0==SYNCHRONIZED||LA35_0==TRANSIENT||(LA35_0>=VOID && LA35_0<=VOLATILE)||LA35_0==LBRACE||LA35_0==SEMI||LA35_0==MONKEYS_AT||LA35_0==LT) ) { |
| alt35=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(35);} |
| |
| switch (alt35) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:482:10: classBodyDeclaration |
| { |
| dbg.location(482,10); |
| pushFollow(FOLLOW_classBodyDeclaration_in_classBody1468); |
| classBodyDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop35; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(35);} |
| |
| dbg.location(484,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_classBody1489); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 22, classBody_StartIndex); } |
| } |
| dbg.location(485, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classBody"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classBody" |
| |
| |
| // $ANTLR start "interfaceBody" |
| // src/com/google/doclava/parser/Java.g:487:1: interfaceBody : '{' ( interfaceBodyDeclaration )* '}' ; |
| public final void interfaceBody() throws RecognitionException { |
| int interfaceBody_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "interfaceBody"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(487, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:488:5: ( '{' ( interfaceBodyDeclaration )* '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:488:9: '{' ( interfaceBodyDeclaration )* '}' |
| { |
| dbg.location(488,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_interfaceBody1508); if (state.failed) return ; |
| dbg.location(489,9); |
| // src/com/google/doclava/parser/Java.g:489:9: ( interfaceBodyDeclaration )* |
| try { dbg.enterSubRule(36); |
| |
| loop36: |
| do { |
| int alt36=2; |
| try { dbg.enterDecision(36, decisionCanBacktrack[36]); |
| |
| int LA36_0 = input.LA(1); |
| |
| if ( (LA36_0==IDENTIFIER||LA36_0==ABSTRACT||LA36_0==BOOLEAN||LA36_0==BYTE||(LA36_0>=CHAR && LA36_0<=CLASS)||LA36_0==DOUBLE||LA36_0==ENUM||LA36_0==FINAL||LA36_0==FLOAT||(LA36_0>=INT && LA36_0<=NATIVE)||(LA36_0>=PRIVATE && LA36_0<=PUBLIC)||(LA36_0>=SHORT && LA36_0<=STRICTFP)||LA36_0==SYNCHRONIZED||LA36_0==TRANSIENT||(LA36_0>=VOID && LA36_0<=VOLATILE)||LA36_0==SEMI||LA36_0==MONKEYS_AT||LA36_0==LT) ) { |
| alt36=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(36);} |
| |
| switch (alt36) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:489:10: interfaceBodyDeclaration |
| { |
| dbg.location(489,10); |
| pushFollow(FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519); |
| interfaceBodyDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop36; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(36);} |
| |
| dbg.location(491,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_interfaceBody1540); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 23, interfaceBody_StartIndex); } |
| } |
| dbg.location(492, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "interfaceBody"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "interfaceBody" |
| |
| |
| // $ANTLR start "classBodyDeclaration" |
| // src/com/google/doclava/parser/Java.g:494:1: classBodyDeclaration : ( ';' | ( 'static' )? block | memberDecl ); |
| public final void classBodyDeclaration() throws RecognitionException { |
| int classBodyDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classBodyDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(494, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:495:5: ( ';' | ( 'static' )? block | memberDecl ) |
| int alt38=3; |
| try { dbg.enterDecision(38, decisionCanBacktrack[38]); |
| |
| switch ( input.LA(1) ) { |
| case SEMI: |
| { |
| alt38=1; |
| } |
| break; |
| case STATIC: |
| { |
| int LA38_2 = input.LA(2); |
| |
| if ( (LA38_2==LBRACE) ) { |
| alt38=2; |
| } |
| else if ( (LA38_2==IDENTIFIER||LA38_2==ABSTRACT||LA38_2==BOOLEAN||LA38_2==BYTE||(LA38_2>=CHAR && LA38_2<=CLASS)||LA38_2==DOUBLE||LA38_2==ENUM||LA38_2==FINAL||LA38_2==FLOAT||(LA38_2>=INT && LA38_2<=NATIVE)||(LA38_2>=PRIVATE && LA38_2<=PUBLIC)||(LA38_2>=SHORT && LA38_2<=STRICTFP)||LA38_2==SYNCHRONIZED||LA38_2==TRANSIENT||(LA38_2>=VOID && LA38_2<=VOLATILE)||LA38_2==MONKEYS_AT||LA38_2==LT) ) { |
| alt38=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 38, 2, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| break; |
| case LBRACE: |
| { |
| alt38=2; |
| } |
| break; |
| case IDENTIFIER: |
| case ABSTRACT: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case CLASS: |
| case DOUBLE: |
| case ENUM: |
| case FINAL: |
| case FLOAT: |
| case INT: |
| case INTERFACE: |
| case LONG: |
| case NATIVE: |
| case PRIVATE: |
| case PROTECTED: |
| case PUBLIC: |
| case SHORT: |
| case STRICTFP: |
| case SYNCHRONIZED: |
| case TRANSIENT: |
| case VOID: |
| case VOLATILE: |
| case MONKEYS_AT: |
| case LT: |
| { |
| alt38=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 38, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } finally {dbg.exitDecision(38);} |
| |
| switch (alt38) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:495:9: ';' |
| { |
| dbg.location(495,9); |
| match(input,SEMI,FOLLOW_SEMI_in_classBodyDeclaration1559); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )? block |
| { |
| dbg.location(496,9); |
| // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )? |
| int alt37=2; |
| try { dbg.enterSubRule(37); |
| try { dbg.enterDecision(37, decisionCanBacktrack[37]); |
| |
| int LA37_0 = input.LA(1); |
| |
| if ( (LA37_0==STATIC) ) { |
| alt37=1; |
| } |
| } finally {dbg.exitDecision(37);} |
| |
| switch (alt37) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:496:10: 'static' |
| { |
| dbg.location(496,10); |
| match(input,STATIC,FOLLOW_STATIC_in_classBodyDeclaration1570); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(37);} |
| |
| dbg.location(498,9); |
| pushFollow(FOLLOW_block_in_classBodyDeclaration1591); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:499:9: memberDecl |
| { |
| dbg.location(499,9); |
| pushFollow(FOLLOW_memberDecl_in_classBodyDeclaration1601); |
| memberDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 24, classBodyDeclaration_StartIndex); } |
| } |
| dbg.location(500, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classBodyDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classBodyDeclaration" |
| |
| |
| // $ANTLR start "memberDecl" |
| // src/com/google/doclava/parser/Java.g:502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration ); |
| public final void memberDecl() throws RecognitionException { |
| int memberDecl_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "memberDecl"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(502, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:503:5: ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration ) |
| int alt39=4; |
| try { dbg.enterDecision(39, decisionCanBacktrack[39]); |
| |
| try { |
| isCyclicDecision = true; |
| alt39 = dfa39.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(39);} |
| |
| switch (alt39) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration |
| { |
| dbg.location(503,10); |
| pushFollow(FOLLOW_fieldDeclaration_in_memberDecl1621); |
| fieldDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration |
| { |
| dbg.location(504,10); |
| pushFollow(FOLLOW_methodDeclaration_in_memberDecl1632); |
| methodDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:505:10: classDeclaration |
| { |
| dbg.location(505,10); |
| pushFollow(FOLLOW_classDeclaration_in_memberDecl1643); |
| classDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:506:10: interfaceDeclaration |
| { |
| dbg.location(506,10); |
| pushFollow(FOLLOW_interfaceDeclaration_in_memberDecl1654); |
| interfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 25, memberDecl_StartIndex); } |
| } |
| dbg.location(507, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "memberDecl"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "memberDecl" |
| |
| |
| // $ANTLR start "methodDeclaration" |
| // src/com/google/doclava/parser/Java.g:510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) ); |
| public final void methodDeclaration() throws RecognitionException { |
| int methodDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "methodDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(510, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:511:5: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) ) |
| int alt49=2; |
| try { dbg.enterDecision(49, decisionCanBacktrack[49]); |
| |
| try { |
| isCyclicDecision = true; |
| alt49 = dfa49.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(49);} |
| |
| switch (alt49) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' |
| { |
| dbg.location(513,10); |
| pushFollow(FOLLOW_modifiers_in_methodDeclaration1691); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(514,9); |
| // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )? |
| int alt40=2; |
| try { dbg.enterSubRule(40); |
| try { dbg.enterDecision(40, decisionCanBacktrack[40]); |
| |
| int LA40_0 = input.LA(1); |
| |
| if ( (LA40_0==LT) ) { |
| alt40=1; |
| } |
| } finally {dbg.exitDecision(40);} |
| |
| switch (alt40) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:514:10: typeParameters |
| { |
| dbg.location(514,10); |
| pushFollow(FOLLOW_typeParameters_in_methodDeclaration1702); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(40);} |
| |
| dbg.location(516,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1723); if (state.failed) return ; |
| dbg.location(517,9); |
| pushFollow(FOLLOW_formalParameters_in_methodDeclaration1733); |
| formalParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(518,9); |
| // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )? |
| int alt41=2; |
| try { dbg.enterSubRule(41); |
| try { dbg.enterDecision(41, decisionCanBacktrack[41]); |
| |
| int LA41_0 = input.LA(1); |
| |
| if ( (LA41_0==THROWS) ) { |
| alt41=1; |
| } |
| } finally {dbg.exitDecision(41);} |
| |
| switch (alt41) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList |
| { |
| dbg.location(518,10); |
| match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1744); if (state.failed) return ; |
| dbg.location(518,19); |
| pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1746); |
| qualifiedNameList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(41);} |
| |
| dbg.location(520,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_methodDeclaration1767); if (state.failed) return ; |
| dbg.location(521,9); |
| // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )? |
| int alt42=2; |
| try { dbg.enterSubRule(42); |
| try { dbg.enterDecision(42, decisionCanBacktrack[42]); |
| |
| try { |
| isCyclicDecision = true; |
| alt42 = dfa42.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(42);} |
| |
| switch (alt42) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation |
| { |
| dbg.location(521,10); |
| pushFollow(FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778); |
| explicitConstructorInvocation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(42);} |
| |
| dbg.location(523,9); |
| // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )* |
| try { dbg.enterSubRule(43); |
| |
| loop43: |
| do { |
| int alt43=2; |
| try { dbg.enterDecision(43, decisionCanBacktrack[43]); |
| |
| int LA43_0 = input.LA(1); |
| |
| if ( ((LA43_0>=IDENTIFIER && LA43_0<=NULL)||(LA43_0>=ABSTRACT && LA43_0<=BYTE)||(LA43_0>=CHAR && LA43_0<=CLASS)||LA43_0==CONTINUE||(LA43_0>=DO && LA43_0<=DOUBLE)||LA43_0==ENUM||LA43_0==FINAL||(LA43_0>=FLOAT && LA43_0<=FOR)||LA43_0==IF||(LA43_0>=INT && LA43_0<=NEW)||(LA43_0>=PRIVATE && LA43_0<=THROW)||(LA43_0>=TRANSIENT && LA43_0<=LPAREN)||LA43_0==LBRACE||LA43_0==SEMI||(LA43_0>=BANG && LA43_0<=TILDE)||(LA43_0>=PLUSPLUS && LA43_0<=SUB)||LA43_0==MONKEYS_AT||LA43_0==LT) ) { |
| alt43=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(43);} |
| |
| switch (alt43) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:523:10: blockStatement |
| { |
| dbg.location(523,10); |
| pushFollow(FOLLOW_blockStatement_in_methodDeclaration1800); |
| blockStatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop43; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(43);} |
| |
| dbg.location(525,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_methodDeclaration1821); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:526:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) |
| { |
| dbg.location(526,9); |
| pushFollow(FOLLOW_modifiers_in_methodDeclaration1831); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(527,9); |
| // src/com/google/doclava/parser/Java.g:527:9: ( typeParameters )? |
| int alt44=2; |
| try { dbg.enterSubRule(44); |
| try { dbg.enterDecision(44, decisionCanBacktrack[44]); |
| |
| int LA44_0 = input.LA(1); |
| |
| if ( (LA44_0==LT) ) { |
| alt44=1; |
| } |
| } finally {dbg.exitDecision(44);} |
| |
| switch (alt44) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:527:10: typeParameters |
| { |
| dbg.location(527,10); |
| pushFollow(FOLLOW_typeParameters_in_methodDeclaration1842); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(44);} |
| |
| dbg.location(529,9); |
| // src/com/google/doclava/parser/Java.g:529:9: ( type | 'void' ) |
| int alt45=2; |
| try { dbg.enterSubRule(45); |
| try { dbg.enterDecision(45, decisionCanBacktrack[45]); |
| |
| int LA45_0 = input.LA(1); |
| |
| if ( (LA45_0==IDENTIFIER||LA45_0==BOOLEAN||LA45_0==BYTE||LA45_0==CHAR||LA45_0==DOUBLE||LA45_0==FLOAT||LA45_0==INT||LA45_0==LONG||LA45_0==SHORT) ) { |
| alt45=1; |
| } |
| else if ( (LA45_0==VOID) ) { |
| alt45=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 45, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(45);} |
| |
| switch (alt45) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:529:10: type |
| { |
| dbg.location(529,10); |
| pushFollow(FOLLOW_type_in_methodDeclaration1864); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:530:13: 'void' |
| { |
| dbg.location(530,13); |
| match(input,VOID,FOLLOW_VOID_in_methodDeclaration1878); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(45);} |
| |
| dbg.location(532,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1898); if (state.failed) return ; |
| dbg.location(533,9); |
| pushFollow(FOLLOW_formalParameters_in_methodDeclaration1908); |
| formalParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(534,9); |
| // src/com/google/doclava/parser/Java.g:534:9: ( '[' ']' )* |
| try { dbg.enterSubRule(46); |
| |
| loop46: |
| do { |
| int alt46=2; |
| try { dbg.enterDecision(46, decisionCanBacktrack[46]); |
| |
| int LA46_0 = input.LA(1); |
| |
| if ( (LA46_0==LBRACKET) ) { |
| alt46=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(46);} |
| |
| switch (alt46) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:534:10: '[' ']' |
| { |
| dbg.location(534,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration1919); if (state.failed) return ; |
| dbg.location(534,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration1921); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop46; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(46);} |
| |
| dbg.location(536,9); |
| // src/com/google/doclava/parser/Java.g:536:9: ( 'throws' qualifiedNameList )? |
| int alt47=2; |
| try { dbg.enterSubRule(47); |
| try { dbg.enterDecision(47, decisionCanBacktrack[47]); |
| |
| int LA47_0 = input.LA(1); |
| |
| if ( (LA47_0==THROWS) ) { |
| alt47=1; |
| } |
| } finally {dbg.exitDecision(47);} |
| |
| switch (alt47) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:536:10: 'throws' qualifiedNameList |
| { |
| dbg.location(536,10); |
| match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1943); if (state.failed) return ; |
| dbg.location(536,19); |
| pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1945); |
| qualifiedNameList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(47);} |
| |
| dbg.location(538,9); |
| // src/com/google/doclava/parser/Java.g:538:9: ( block | ';' ) |
| int alt48=2; |
| try { dbg.enterSubRule(48); |
| try { dbg.enterDecision(48, decisionCanBacktrack[48]); |
| |
| int LA48_0 = input.LA(1); |
| |
| if ( (LA48_0==LBRACE) ) { |
| alt48=1; |
| } |
| else if ( (LA48_0==SEMI) ) { |
| alt48=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 48, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(48);} |
| |
| switch (alt48) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:539:13: block |
| { |
| dbg.location(539,13); |
| pushFollow(FOLLOW_block_in_methodDeclaration1980); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:540:13: ';' |
| { |
| dbg.location(540,13); |
| match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration1994); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(48);} |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 26, methodDeclaration_StartIndex); } |
| } |
| dbg.location(542, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "methodDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "methodDeclaration" |
| |
| |
| // $ANTLR start "fieldDeclaration" |
| // src/com/google/doclava/parser/Java.g:545:1: fieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ; |
| public final void fieldDeclaration() throws RecognitionException { |
| int fieldDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "fieldDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(545, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:546:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:546:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';' |
| { |
| dbg.location(546,9); |
| pushFollow(FOLLOW_modifiers_in_fieldDeclaration2024); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(547,9); |
| pushFollow(FOLLOW_type_in_fieldDeclaration2034); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(548,9); |
| pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2044); |
| variableDeclarator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(549,9); |
| // src/com/google/doclava/parser/Java.g:549:9: ( ',' variableDeclarator )* |
| try { dbg.enterSubRule(50); |
| |
| loop50: |
| do { |
| int alt50=2; |
| try { dbg.enterDecision(50, decisionCanBacktrack[50]); |
| |
| int LA50_0 = input.LA(1); |
| |
| if ( (LA50_0==COMMA) ) { |
| alt50=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(50);} |
| |
| switch (alt50) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:549:10: ',' variableDeclarator |
| { |
| dbg.location(549,10); |
| match(input,COMMA,FOLLOW_COMMA_in_fieldDeclaration2055); if (state.failed) return ; |
| dbg.location(549,14); |
| pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2057); |
| variableDeclarator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop50; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(50);} |
| |
| dbg.location(551,9); |
| match(input,SEMI,FOLLOW_SEMI_in_fieldDeclaration2078); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 27, fieldDeclaration_StartIndex); } |
| } |
| dbg.location(552, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "fieldDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "fieldDeclaration" |
| |
| |
| // $ANTLR start "variableDeclarator" |
| // src/com/google/doclava/parser/Java.g:554:1: variableDeclarator : IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? ; |
| public final void variableDeclarator() throws RecognitionException { |
| int variableDeclarator_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "variableDeclarator"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(554, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:555:5: ( IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:555:9: IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? |
| { |
| dbg.location(555,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclarator2097); if (state.failed) return ; |
| dbg.location(556,9); |
| // src/com/google/doclava/parser/Java.g:556:9: ( '[' ']' )* |
| try { dbg.enterSubRule(51); |
| |
| loop51: |
| do { |
| int alt51=2; |
| try { dbg.enterDecision(51, decisionCanBacktrack[51]); |
| |
| int LA51_0 = input.LA(1); |
| |
| if ( (LA51_0==LBRACKET) ) { |
| alt51=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(51);} |
| |
| switch (alt51) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:556:10: '[' ']' |
| { |
| dbg.location(556,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_variableDeclarator2108); if (state.failed) return ; |
| dbg.location(556,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_variableDeclarator2110); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop51; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(51);} |
| |
| dbg.location(558,9); |
| // src/com/google/doclava/parser/Java.g:558:9: ( '=' variableInitializer )? |
| int alt52=2; |
| try { dbg.enterSubRule(52); |
| try { dbg.enterDecision(52, decisionCanBacktrack[52]); |
| |
| int LA52_0 = input.LA(1); |
| |
| if ( (LA52_0==EQ) ) { |
| alt52=1; |
| } |
| } finally {dbg.exitDecision(52);} |
| |
| switch (alt52) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:558:10: '=' variableInitializer |
| { |
| dbg.location(558,10); |
| match(input,EQ,FOLLOW_EQ_in_variableDeclarator2132); if (state.failed) return ; |
| dbg.location(558,14); |
| pushFollow(FOLLOW_variableInitializer_in_variableDeclarator2134); |
| variableInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(52);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 28, variableDeclarator_StartIndex); } |
| } |
| dbg.location(560, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "variableDeclarator"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "variableDeclarator" |
| |
| |
| // $ANTLR start "interfaceBodyDeclaration" |
| // src/com/google/doclava/parser/Java.g:562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' ); |
| public final void interfaceBodyDeclaration() throws RecognitionException { |
| int interfaceBodyDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "interfaceBodyDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(562, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:566:5: ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' ) |
| int alt53=5; |
| try { dbg.enterDecision(53, decisionCanBacktrack[53]); |
| |
| try { |
| isCyclicDecision = true; |
| alt53 = dfa53.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(53);} |
| |
| switch (alt53) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration |
| { |
| dbg.location(567,9); |
| pushFollow(FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172); |
| interfaceFieldDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration |
| { |
| dbg.location(568,9); |
| pushFollow(FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182); |
| interfaceMethodDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration |
| { |
| dbg.location(569,9); |
| pushFollow(FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192); |
| interfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:570:9: classDeclaration |
| { |
| dbg.location(570,9); |
| pushFollow(FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202); |
| classDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:571:9: ';' |
| { |
| dbg.location(571,9); |
| match(input,SEMI,FOLLOW_SEMI_in_interfaceBodyDeclaration2212); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 29, interfaceBodyDeclaration_StartIndex); } |
| } |
| dbg.location(572, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "interfaceBodyDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "interfaceBodyDeclaration" |
| |
| |
| // $ANTLR start "interfaceMethodDeclaration" |
| // src/com/google/doclava/parser/Java.g:574:1: interfaceMethodDeclaration : modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' ; |
| public final void interfaceMethodDeclaration() throws RecognitionException { |
| int interfaceMethodDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "interfaceMethodDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(574, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:575:5: ( modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:575:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' |
| { |
| dbg.location(575,9); |
| pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration2231); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(576,9); |
| // src/com/google/doclava/parser/Java.g:576:9: ( typeParameters )? |
| int alt54=2; |
| try { dbg.enterSubRule(54); |
| try { dbg.enterDecision(54, decisionCanBacktrack[54]); |
| |
| int LA54_0 = input.LA(1); |
| |
| if ( (LA54_0==LT) ) { |
| alt54=1; |
| } |
| } finally {dbg.exitDecision(54);} |
| |
| switch (alt54) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:576:10: typeParameters |
| { |
| dbg.location(576,10); |
| pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration2242); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(54);} |
| |
| dbg.location(578,9); |
| // src/com/google/doclava/parser/Java.g:578:9: ( type | 'void' ) |
| int alt55=2; |
| try { dbg.enterSubRule(55); |
| try { dbg.enterDecision(55, decisionCanBacktrack[55]); |
| |
| int LA55_0 = input.LA(1); |
| |
| if ( (LA55_0==IDENTIFIER||LA55_0==BOOLEAN||LA55_0==BYTE||LA55_0==CHAR||LA55_0==DOUBLE||LA55_0==FLOAT||LA55_0==INT||LA55_0==LONG||LA55_0==SHORT) ) { |
| alt55=1; |
| } |
| else if ( (LA55_0==VOID) ) { |
| alt55=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 55, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(55);} |
| |
| switch (alt55) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:578:10: type |
| { |
| dbg.location(578,10); |
| pushFollow(FOLLOW_type_in_interfaceMethodDeclaration2264); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:579:10: 'void' |
| { |
| dbg.location(579,10); |
| match(input,VOID,FOLLOW_VOID_in_interfaceMethodDeclaration2275); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(55);} |
| |
| dbg.location(581,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295); if (state.failed) return ; |
| dbg.location(582,9); |
| pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration2305); |
| formalParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(583,9); |
| // src/com/google/doclava/parser/Java.g:583:9: ( '[' ']' )* |
| try { dbg.enterSubRule(56); |
| |
| loop56: |
| do { |
| int alt56=2; |
| try { dbg.enterDecision(56, decisionCanBacktrack[56]); |
| |
| int LA56_0 = input.LA(1); |
| |
| if ( (LA56_0==LBRACKET) ) { |
| alt56=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(56);} |
| |
| switch (alt56) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:583:10: '[' ']' |
| { |
| dbg.location(583,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316); if (state.failed) return ; |
| dbg.location(583,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop56; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(56);} |
| |
| dbg.location(585,9); |
| // src/com/google/doclava/parser/Java.g:585:9: ( 'throws' qualifiedNameList )? |
| int alt57=2; |
| try { dbg.enterSubRule(57); |
| try { dbg.enterDecision(57, decisionCanBacktrack[57]); |
| |
| int LA57_0 = input.LA(1); |
| |
| if ( (LA57_0==THROWS) ) { |
| alt57=1; |
| } |
| } finally {dbg.exitDecision(57);} |
| |
| switch (alt57) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:585:10: 'throws' qualifiedNameList |
| { |
| dbg.location(585,10); |
| match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration2340); if (state.failed) return ; |
| dbg.location(585,19); |
| pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342); |
| qualifiedNameList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(57);} |
| |
| dbg.location(586,12); |
| match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration2355); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 30, interfaceMethodDeclaration_StartIndex); } |
| } |
| dbg.location(587, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "interfaceMethodDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "interfaceMethodDeclaration" |
| |
| |
| // $ANTLR start "interfaceFieldDeclaration" |
| // src/com/google/doclava/parser/Java.g:589:1: interfaceFieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ; |
| public final void interfaceFieldDeclaration() throws RecognitionException { |
| int interfaceFieldDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "interfaceFieldDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(589, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:595:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:595:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';' |
| { |
| dbg.location(595,9); |
| pushFollow(FOLLOW_modifiers_in_interfaceFieldDeclaration2376); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(595,19); |
| pushFollow(FOLLOW_type_in_interfaceFieldDeclaration2378); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(595,24); |
| pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380); |
| variableDeclarator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(596,9); |
| // src/com/google/doclava/parser/Java.g:596:9: ( ',' variableDeclarator )* |
| try { dbg.enterSubRule(58); |
| |
| loop58: |
| do { |
| int alt58=2; |
| try { dbg.enterDecision(58, decisionCanBacktrack[58]); |
| |
| int LA58_0 = input.LA(1); |
| |
| if ( (LA58_0==COMMA) ) { |
| alt58=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(58);} |
| |
| switch (alt58) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:596:10: ',' variableDeclarator |
| { |
| dbg.location(596,10); |
| match(input,COMMA,FOLLOW_COMMA_in_interfaceFieldDeclaration2391); if (state.failed) return ; |
| dbg.location(596,14); |
| pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393); |
| variableDeclarator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop58; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(58);} |
| |
| dbg.location(598,9); |
| match(input,SEMI,FOLLOW_SEMI_in_interfaceFieldDeclaration2414); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 31, interfaceFieldDeclaration_StartIndex); } |
| } |
| dbg.location(599, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "interfaceFieldDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "interfaceFieldDeclaration" |
| |
| |
| // $ANTLR start "type" |
| // src/com/google/doclava/parser/Java.g:602:1: type : ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* ); |
| public final void type() throws RecognitionException { |
| int type_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "type"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(602, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:603:5: ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* ) |
| int alt61=2; |
| try { dbg.enterDecision(61, decisionCanBacktrack[61]); |
| |
| int LA61_0 = input.LA(1); |
| |
| if ( (LA61_0==IDENTIFIER) ) { |
| alt61=1; |
| } |
| else if ( (LA61_0==BOOLEAN||LA61_0==BYTE||LA61_0==CHAR||LA61_0==DOUBLE||LA61_0==FLOAT||LA61_0==INT||LA61_0==LONG||LA61_0==SHORT) ) { |
| alt61=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 61, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(61);} |
| |
| switch (alt61) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:603:9: classOrInterfaceType ( '[' ']' )* |
| { |
| dbg.location(603,9); |
| pushFollow(FOLLOW_classOrInterfaceType_in_type2434); |
| classOrInterfaceType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(604,9); |
| // src/com/google/doclava/parser/Java.g:604:9: ( '[' ']' )* |
| try { dbg.enterSubRule(59); |
| |
| loop59: |
| do { |
| int alt59=2; |
| try { dbg.enterDecision(59, decisionCanBacktrack[59]); |
| |
| int LA59_0 = input.LA(1); |
| |
| if ( (LA59_0==LBRACKET) ) { |
| alt59=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(59);} |
| |
| switch (alt59) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:604:10: '[' ']' |
| { |
| dbg.location(604,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_type2445); if (state.failed) return ; |
| dbg.location(604,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_type2447); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop59; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(59);} |
| |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:606:9: primitiveType ( '[' ']' )* |
| { |
| dbg.location(606,9); |
| pushFollow(FOLLOW_primitiveType_in_type2468); |
| primitiveType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(607,9); |
| // src/com/google/doclava/parser/Java.g:607:9: ( '[' ']' )* |
| try { dbg.enterSubRule(60); |
| |
| loop60: |
| do { |
| int alt60=2; |
| try { dbg.enterDecision(60, decisionCanBacktrack[60]); |
| |
| int LA60_0 = input.LA(1); |
| |
| if ( (LA60_0==LBRACKET) ) { |
| alt60=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(60);} |
| |
| switch (alt60) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:607:10: '[' ']' |
| { |
| dbg.location(607,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_type2479); if (state.failed) return ; |
| dbg.location(607,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_type2481); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop60; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(60);} |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 32, type_StartIndex); } |
| } |
| dbg.location(609, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "type"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "type" |
| |
| |
| // $ANTLR start "classOrInterfaceType" |
| // src/com/google/doclava/parser/Java.g:612:1: classOrInterfaceType : IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* ; |
| public final void classOrInterfaceType() throws RecognitionException { |
| int classOrInterfaceType_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceType"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(612, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:613:5: ( IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:613:9: IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* |
| { |
| dbg.location(613,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2512); if (state.failed) return ; |
| dbg.location(614,9); |
| // src/com/google/doclava/parser/Java.g:614:9: ( typeArguments )? |
| int alt62=2; |
| try { dbg.enterSubRule(62); |
| try { dbg.enterDecision(62, decisionCanBacktrack[62]); |
| |
| int LA62_0 = input.LA(1); |
| |
| if ( (LA62_0==LT) ) { |
| int LA62_1 = input.LA(2); |
| |
| if ( (LA62_1==IDENTIFIER||LA62_1==BOOLEAN||LA62_1==BYTE||LA62_1==CHAR||LA62_1==DOUBLE||LA62_1==FLOAT||LA62_1==INT||LA62_1==LONG||LA62_1==SHORT||LA62_1==QUES) ) { |
| alt62=1; |
| } |
| } |
| } finally {dbg.exitDecision(62);} |
| |
| switch (alt62) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:614:10: typeArguments |
| { |
| dbg.location(614,10); |
| pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2523); |
| typeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(62);} |
| |
| dbg.location(616,9); |
| // src/com/google/doclava/parser/Java.g:616:9: ( '.' IDENTIFIER ( typeArguments )? )* |
| try { dbg.enterSubRule(64); |
| |
| loop64: |
| do { |
| int alt64=2; |
| try { dbg.enterDecision(64, decisionCanBacktrack[64]); |
| |
| int LA64_0 = input.LA(1); |
| |
| if ( (LA64_0==DOT) ) { |
| alt64=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(64);} |
| |
| switch (alt64) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:616:10: '.' IDENTIFIER ( typeArguments )? |
| { |
| dbg.location(616,10); |
| match(input,DOT,FOLLOW_DOT_in_classOrInterfaceType2545); if (state.failed) return ; |
| dbg.location(616,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2547); if (state.failed) return ; |
| dbg.location(617,13); |
| // src/com/google/doclava/parser/Java.g:617:13: ( typeArguments )? |
| int alt63=2; |
| try { dbg.enterSubRule(63); |
| try { dbg.enterDecision(63, decisionCanBacktrack[63]); |
| |
| int LA63_0 = input.LA(1); |
| |
| if ( (LA63_0==LT) ) { |
| int LA63_1 = input.LA(2); |
| |
| if ( (LA63_1==IDENTIFIER||LA63_1==BOOLEAN||LA63_1==BYTE||LA63_1==CHAR||LA63_1==DOUBLE||LA63_1==FLOAT||LA63_1==INT||LA63_1==LONG||LA63_1==SHORT||LA63_1==QUES) ) { |
| alt63=1; |
| } |
| } |
| } finally {dbg.exitDecision(63);} |
| |
| switch (alt63) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:617:14: typeArguments |
| { |
| dbg.location(617,14); |
| pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2562); |
| typeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(63);} |
| |
| |
| } |
| break; |
| |
| default : |
| break loop64; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(64);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 33, classOrInterfaceType_StartIndex); } |
| } |
| dbg.location(620, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classOrInterfaceType"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classOrInterfaceType" |
| |
| |
| // $ANTLR start "primitiveType" |
| // src/com/google/doclava/parser/Java.g:622:1: primitiveType : ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' ); |
| public final void primitiveType() throws RecognitionException { |
| int primitiveType_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "primitiveType"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(622, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:623:5: ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g: |
| { |
| dbg.location(623,5); |
| if ( input.LA(1)==BOOLEAN||input.LA(1)==BYTE||input.LA(1)==CHAR||input.LA(1)==DOUBLE||input.LA(1)==FLOAT||input.LA(1)==INT||input.LA(1)==LONG||input.LA(1)==SHORT ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 34, primitiveType_StartIndex); } |
| } |
| dbg.location(631, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "primitiveType"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "primitiveType" |
| |
| |
| // $ANTLR start "typeArguments" |
| // src/com/google/doclava/parser/Java.g:633:1: typeArguments : '<' typeArgument ( ',' typeArgument )* '>' ; |
| public final void typeArguments() throws RecognitionException { |
| int typeArguments_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeArguments"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(633, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:634:5: ( '<' typeArgument ( ',' typeArgument )* '>' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:634:9: '<' typeArgument ( ',' typeArgument )* '>' |
| { |
| dbg.location(634,9); |
| match(input,LT,FOLLOW_LT_in_typeArguments2696); if (state.failed) return ; |
| dbg.location(634,13); |
| pushFollow(FOLLOW_typeArgument_in_typeArguments2698); |
| typeArgument(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(635,9); |
| // src/com/google/doclava/parser/Java.g:635:9: ( ',' typeArgument )* |
| try { dbg.enterSubRule(65); |
| |
| loop65: |
| do { |
| int alt65=2; |
| try { dbg.enterDecision(65, decisionCanBacktrack[65]); |
| |
| int LA65_0 = input.LA(1); |
| |
| if ( (LA65_0==COMMA) ) { |
| alt65=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(65);} |
| |
| switch (alt65) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:635:10: ',' typeArgument |
| { |
| dbg.location(635,10); |
| match(input,COMMA,FOLLOW_COMMA_in_typeArguments2709); if (state.failed) return ; |
| dbg.location(635,14); |
| pushFollow(FOLLOW_typeArgument_in_typeArguments2711); |
| typeArgument(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop65; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(65);} |
| |
| dbg.location(637,9); |
| match(input,GT,FOLLOW_GT_in_typeArguments2732); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 35, typeArguments_StartIndex); } |
| } |
| dbg.location(638, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeArguments"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeArguments" |
| |
| |
| // $ANTLR start "typeArgument" |
| // src/com/google/doclava/parser/Java.g:640:1: typeArgument : ( type | '?' ( ( 'extends' | 'super' ) type )? ); |
| public final void typeArgument() throws RecognitionException { |
| int typeArgument_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeArgument"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(640, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:641:5: ( type | '?' ( ( 'extends' | 'super' ) type )? ) |
| int alt67=2; |
| try { dbg.enterDecision(67, decisionCanBacktrack[67]); |
| |
| int LA67_0 = input.LA(1); |
| |
| if ( (LA67_0==IDENTIFIER||LA67_0==BOOLEAN||LA67_0==BYTE||LA67_0==CHAR||LA67_0==DOUBLE||LA67_0==FLOAT||LA67_0==INT||LA67_0==LONG||LA67_0==SHORT) ) { |
| alt67=1; |
| } |
| else if ( (LA67_0==QUES) ) { |
| alt67=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 67, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(67);} |
| |
| switch (alt67) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:641:9: type |
| { |
| dbg.location(641,9); |
| pushFollow(FOLLOW_type_in_typeArgument2751); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:642:9: '?' ( ( 'extends' | 'super' ) type )? |
| { |
| dbg.location(642,9); |
| match(input,QUES,FOLLOW_QUES_in_typeArgument2761); if (state.failed) return ; |
| dbg.location(643,9); |
| // src/com/google/doclava/parser/Java.g:643:9: ( ( 'extends' | 'super' ) type )? |
| int alt66=2; |
| try { dbg.enterSubRule(66); |
| try { dbg.enterDecision(66, decisionCanBacktrack[66]); |
| |
| int LA66_0 = input.LA(1); |
| |
| if ( (LA66_0==EXTENDS||LA66_0==SUPER) ) { |
| alt66=1; |
| } |
| } finally {dbg.exitDecision(66);} |
| |
| switch (alt66) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:644:13: ( 'extends' | 'super' ) type |
| { |
| dbg.location(644,13); |
| if ( input.LA(1)==EXTENDS||input.LA(1)==SUPER ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(647,13); |
| pushFollow(FOLLOW_type_in_typeArgument2829); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(66);} |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 36, typeArgument_StartIndex); } |
| } |
| dbg.location(649, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeArgument"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeArgument" |
| |
| |
| // $ANTLR start "qualifiedNameList" |
| // src/com/google/doclava/parser/Java.g:651:1: qualifiedNameList : qualifiedName ( ',' qualifiedName )* ; |
| public final void qualifiedNameList() throws RecognitionException { |
| int qualifiedNameList_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "qualifiedNameList"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(651, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:652:5: ( qualifiedName ( ',' qualifiedName )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:652:9: qualifiedName ( ',' qualifiedName )* |
| { |
| dbg.location(652,9); |
| pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2859); |
| qualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(653,9); |
| // src/com/google/doclava/parser/Java.g:653:9: ( ',' qualifiedName )* |
| try { dbg.enterSubRule(68); |
| |
| loop68: |
| do { |
| int alt68=2; |
| try { dbg.enterDecision(68, decisionCanBacktrack[68]); |
| |
| int LA68_0 = input.LA(1); |
| |
| if ( (LA68_0==COMMA) ) { |
| alt68=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(68);} |
| |
| switch (alt68) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:653:10: ',' qualifiedName |
| { |
| dbg.location(653,10); |
| match(input,COMMA,FOLLOW_COMMA_in_qualifiedNameList2870); if (state.failed) return ; |
| dbg.location(653,14); |
| pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2872); |
| qualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop68; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(68);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 37, qualifiedNameList_StartIndex); } |
| } |
| dbg.location(655, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "qualifiedNameList"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "qualifiedNameList" |
| |
| |
| // $ANTLR start "formalParameters" |
| // src/com/google/doclava/parser/Java.g:657:1: formalParameters : '(' ( formalParameterDecls )? ')' ; |
| public final void formalParameters() throws RecognitionException { |
| int formalParameters_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "formalParameters"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(657, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:658:5: ( '(' ( formalParameterDecls )? ')' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:658:9: '(' ( formalParameterDecls )? ')' |
| { |
| dbg.location(658,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_formalParameters2902); if (state.failed) return ; |
| dbg.location(659,9); |
| // src/com/google/doclava/parser/Java.g:659:9: ( formalParameterDecls )? |
| int alt69=2; |
| try { dbg.enterSubRule(69); |
| try { dbg.enterDecision(69, decisionCanBacktrack[69]); |
| |
| int LA69_0 = input.LA(1); |
| |
| if ( (LA69_0==IDENTIFIER||LA69_0==BOOLEAN||LA69_0==BYTE||LA69_0==CHAR||LA69_0==DOUBLE||LA69_0==FINAL||LA69_0==FLOAT||LA69_0==INT||LA69_0==LONG||LA69_0==SHORT||LA69_0==MONKEYS_AT) ) { |
| alt69=1; |
| } |
| } finally {dbg.exitDecision(69);} |
| |
| switch (alt69) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:659:10: formalParameterDecls |
| { |
| dbg.location(659,10); |
| pushFollow(FOLLOW_formalParameterDecls_in_formalParameters2913); |
| formalParameterDecls(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(69);} |
| |
| dbg.location(661,9); |
| match(input,RPAREN,FOLLOW_RPAREN_in_formalParameters2934); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 38, formalParameters_StartIndex); } |
| } |
| dbg.location(662, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "formalParameters"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "formalParameters" |
| |
| |
| // $ANTLR start "formalParameterDecls" |
| // src/com/google/doclava/parser/Java.g:664:1: formalParameterDecls : ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl ); |
| public final void formalParameterDecls() throws RecognitionException { |
| int formalParameterDecls_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "formalParameterDecls"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(664, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:665:5: ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl ) |
| int alt72=3; |
| try { dbg.enterDecision(72, decisionCanBacktrack[72]); |
| |
| switch ( input.LA(1) ) { |
| case FINAL: |
| { |
| int LA72_1 = input.LA(2); |
| |
| if ( (synpred96_Java()) ) { |
| alt72=1; |
| } |
| else if ( (synpred98_Java()) ) { |
| alt72=2; |
| } |
| else if ( (true) ) { |
| alt72=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 72, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| break; |
| case MONKEYS_AT: |
| { |
| int LA72_2 = input.LA(2); |
| |
| if ( (synpred96_Java()) ) { |
| alt72=1; |
| } |
| else if ( (synpred98_Java()) ) { |
| alt72=2; |
| } |
| else if ( (true) ) { |
| alt72=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 72, 2, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| break; |
| case IDENTIFIER: |
| { |
| int LA72_3 = input.LA(2); |
| |
| if ( (synpred96_Java()) ) { |
| alt72=1; |
| } |
| else if ( (synpred98_Java()) ) { |
| alt72=2; |
| } |
| else if ( (true) ) { |
| alt72=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 72, 3, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| break; |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| { |
| int LA72_4 = input.LA(2); |
| |
| if ( (synpred96_Java()) ) { |
| alt72=1; |
| } |
| else if ( (synpred98_Java()) ) { |
| alt72=2; |
| } |
| else if ( (true) ) { |
| alt72=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 72, 4, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 72, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } finally {dbg.exitDecision(72);} |
| |
| switch (alt72) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl |
| { |
| dbg.location(665,9); |
| pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953); |
| ellipsisParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )* |
| { |
| dbg.location(666,9); |
| pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2963); |
| normalParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(667,9); |
| // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )* |
| try { dbg.enterSubRule(70); |
| |
| loop70: |
| do { |
| int alt70=2; |
| try { dbg.enterDecision(70, decisionCanBacktrack[70]); |
| |
| int LA70_0 = input.LA(1); |
| |
| if ( (LA70_0==COMMA) ) { |
| alt70=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(70);} |
| |
| switch (alt70) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl |
| { |
| dbg.location(667,10); |
| match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls2974); if (state.failed) return ; |
| dbg.location(667,14); |
| pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2976); |
| normalParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop70; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(70);} |
| |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+ ellipsisParameterDecl |
| { |
| dbg.location(669,9); |
| // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+ |
| int cnt71=0; |
| try { dbg.enterSubRule(71); |
| |
| loop71: |
| do { |
| int alt71=2; |
| try { dbg.enterDecision(71, decisionCanBacktrack[71]); |
| |
| switch ( input.LA(1) ) { |
| case FINAL: |
| { |
| int LA71_1 = input.LA(2); |
| |
| if ( (synpred99_Java()) ) { |
| alt71=1; |
| } |
| |
| |
| } |
| break; |
| case MONKEYS_AT: |
| { |
| int LA71_2 = input.LA(2); |
| |
| if ( (synpred99_Java()) ) { |
| alt71=1; |
| } |
| |
| |
| } |
| break; |
| case IDENTIFIER: |
| { |
| int LA71_3 = input.LA(2); |
| |
| if ( (synpred99_Java()) ) { |
| alt71=1; |
| } |
| |
| |
| } |
| break; |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| { |
| int LA71_4 = input.LA(2); |
| |
| if ( (synpred99_Java()) ) { |
| alt71=1; |
| } |
| |
| |
| } |
| break; |
| |
| } |
| |
| } finally {dbg.exitDecision(71);} |
| |
| switch (alt71) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ',' |
| { |
| dbg.location(669,10); |
| pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2998); |
| normalParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(670,9); |
| match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls3008); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| if ( cnt71 >= 1 ) break loop71; |
| if (state.backtracking>0) {state.failed=true; return ;} |
| EarlyExitException eee = |
| new EarlyExitException(71, input); |
| dbg.recognitionException(eee); |
| |
| throw eee; |
| } |
| cnt71++; |
| } while (true); |
| } finally {dbg.exitSubRule(71);} |
| |
| dbg.location(672,9); |
| pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029); |
| ellipsisParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 39, formalParameterDecls_StartIndex); } |
| } |
| dbg.location(673, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "formalParameterDecls"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "formalParameterDecls" |
| |
| |
| // $ANTLR start "normalParameterDecl" |
| // src/com/google/doclava/parser/Java.g:675:1: normalParameterDecl : variableModifiers type IDENTIFIER ( '[' ']' )* ; |
| public final void normalParameterDecl() throws RecognitionException { |
| int normalParameterDecl_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "normalParameterDecl"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(675, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:676:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:676:9: variableModifiers type IDENTIFIER ( '[' ']' )* |
| { |
| dbg.location(676,9); |
| pushFollow(FOLLOW_variableModifiers_in_normalParameterDecl3048); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(676,27); |
| pushFollow(FOLLOW_type_in_normalParameterDecl3050); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(676,32); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalParameterDecl3052); if (state.failed) return ; |
| dbg.location(677,9); |
| // src/com/google/doclava/parser/Java.g:677:9: ( '[' ']' )* |
| try { dbg.enterSubRule(73); |
| |
| loop73: |
| do { |
| int alt73=2; |
| try { dbg.enterDecision(73, decisionCanBacktrack[73]); |
| |
| int LA73_0 = input.LA(1); |
| |
| if ( (LA73_0==LBRACKET) ) { |
| alt73=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(73);} |
| |
| switch (alt73) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:677:10: '[' ']' |
| { |
| dbg.location(677,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_normalParameterDecl3063); if (state.failed) return ; |
| dbg.location(677,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_normalParameterDecl3065); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop73; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(73);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 40, normalParameterDecl_StartIndex); } |
| } |
| dbg.location(679, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "normalParameterDecl"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "normalParameterDecl" |
| |
| |
| // $ANTLR start "ellipsisParameterDecl" |
| // src/com/google/doclava/parser/Java.g:681:1: ellipsisParameterDecl : variableModifiers type '...' IDENTIFIER ; |
| public final void ellipsisParameterDecl() throws RecognitionException { |
| int ellipsisParameterDecl_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "ellipsisParameterDecl"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(681, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:682:5: ( variableModifiers type '...' IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:682:9: variableModifiers type '...' IDENTIFIER |
| { |
| dbg.location(682,9); |
| pushFollow(FOLLOW_variableModifiers_in_ellipsisParameterDecl3095); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(683,9); |
| pushFollow(FOLLOW_type_in_ellipsisParameterDecl3105); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(683,15); |
| match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108); if (state.failed) return ; |
| dbg.location(684,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 41, ellipsisParameterDecl_StartIndex); } |
| } |
| dbg.location(685, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "ellipsisParameterDecl"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "ellipsisParameterDecl" |
| |
| |
| // $ANTLR start "explicitConstructorInvocation" |
| // src/com/google/doclava/parser/Java.g:688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' ); |
| public final void explicitConstructorInvocation() throws RecognitionException { |
| int explicitConstructorInvocation_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "explicitConstructorInvocation"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(688, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:689:5: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' ) |
| int alt76=2; |
| try { dbg.enterDecision(76, decisionCanBacktrack[76]); |
| |
| try { |
| isCyclicDecision = true; |
| alt76 = dfa76.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(76);} |
| |
| switch (alt76) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' |
| { |
| dbg.location(689,9); |
| // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? |
| int alt74=2; |
| try { dbg.enterSubRule(74); |
| try { dbg.enterDecision(74, decisionCanBacktrack[74]); |
| |
| int LA74_0 = input.LA(1); |
| |
| if ( (LA74_0==LT) ) { |
| alt74=1; |
| } |
| } finally {dbg.exitDecision(74);} |
| |
| switch (alt74) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments |
| { |
| dbg.location(689,10); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(74);} |
| |
| dbg.location(691,9); |
| if ( input.LA(1)==SUPER||input.LA(1)==THIS ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(694,9); |
| pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3197); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(694,19); |
| match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3199); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:696:9: primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' |
| { |
| dbg.location(696,9); |
| pushFollow(FOLLOW_primary_in_explicitConstructorInvocation3210); |
| primary(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(697,9); |
| match(input,DOT,FOLLOW_DOT_in_explicitConstructorInvocation3220); if (state.failed) return ; |
| dbg.location(698,9); |
| // src/com/google/doclava/parser/Java.g:698:9: ( nonWildcardTypeArguments )? |
| int alt75=2; |
| try { dbg.enterSubRule(75); |
| try { dbg.enterDecision(75, decisionCanBacktrack[75]); |
| |
| int LA75_0 = input.LA(1); |
| |
| if ( (LA75_0==LT) ) { |
| alt75=1; |
| } |
| } finally {dbg.exitDecision(75);} |
| |
| switch (alt75) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:698:10: nonWildcardTypeArguments |
| { |
| dbg.location(698,10); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(75);} |
| |
| dbg.location(700,9); |
| match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation3252); if (state.failed) return ; |
| dbg.location(701,9); |
| pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3262); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(701,19); |
| match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3264); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 42, explicitConstructorInvocation_StartIndex); } |
| } |
| dbg.location(702, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "explicitConstructorInvocation"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "explicitConstructorInvocation" |
| |
| |
| // $ANTLR start "qualifiedName" |
| // src/com/google/doclava/parser/Java.g:704:1: qualifiedName : IDENTIFIER ( '.' IDENTIFIER )* ; |
| public final void qualifiedName() throws RecognitionException { |
| int qualifiedName_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "qualifiedName"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(704, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:705:5: ( IDENTIFIER ( '.' IDENTIFIER )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:705:9: IDENTIFIER ( '.' IDENTIFIER )* |
| { |
| dbg.location(705,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3283); if (state.failed) return ; |
| dbg.location(706,9); |
| // src/com/google/doclava/parser/Java.g:706:9: ( '.' IDENTIFIER )* |
| try { dbg.enterSubRule(77); |
| |
| loop77: |
| do { |
| int alt77=2; |
| try { dbg.enterDecision(77, decisionCanBacktrack[77]); |
| |
| int LA77_0 = input.LA(1); |
| |
| if ( (LA77_0==DOT) ) { |
| alt77=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(77);} |
| |
| switch (alt77) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:706:10: '.' IDENTIFIER |
| { |
| dbg.location(706,10); |
| match(input,DOT,FOLLOW_DOT_in_qualifiedName3294); if (state.failed) return ; |
| dbg.location(706,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3296); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop77; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(77);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 43, qualifiedName_StartIndex); } |
| } |
| dbg.location(708, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "qualifiedName"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "qualifiedName" |
| |
| |
| // $ANTLR start "annotations" |
| // src/com/google/doclava/parser/Java.g:710:1: annotations : ( annotation )+ ; |
| public final void annotations() throws RecognitionException { |
| int annotations_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotations"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(710, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:711:5: ( ( annotation )+ ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+ |
| { |
| dbg.location(711,9); |
| // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+ |
| int cnt78=0; |
| try { dbg.enterSubRule(78); |
| |
| loop78: |
| do { |
| int alt78=2; |
| try { dbg.enterDecision(78, decisionCanBacktrack[78]); |
| |
| int LA78_0 = input.LA(1); |
| |
| if ( (LA78_0==MONKEYS_AT) ) { |
| alt78=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(78);} |
| |
| switch (alt78) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:711:10: annotation |
| { |
| dbg.location(711,10); |
| pushFollow(FOLLOW_annotation_in_annotations3327); |
| annotation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| if ( cnt78 >= 1 ) break loop78; |
| if (state.backtracking>0) {state.failed=true; return ;} |
| EarlyExitException eee = |
| new EarlyExitException(78, input); |
| dbg.recognitionException(eee); |
| |
| throw eee; |
| } |
| cnt78++; |
| } while (true); |
| } finally {dbg.exitSubRule(78);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 44, annotations_StartIndex); } |
| } |
| dbg.location(713, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotations"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotations" |
| |
| |
| // $ANTLR start "annotation" |
| // src/com/google/doclava/parser/Java.g:715:1: annotation : '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ; |
| public final void annotation() throws RecognitionException { |
| int annotation_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotation"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(715, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:720:5: ( '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:720:9: '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? |
| { |
| dbg.location(720,9); |
| match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotation3359); if (state.failed) return ; |
| dbg.location(720,13); |
| pushFollow(FOLLOW_qualifiedName_in_annotation3361); |
| qualifiedName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(721,9); |
| // src/com/google/doclava/parser/Java.g:721:9: ( '(' ( elementValuePairs | elementValue )? ')' )? |
| int alt80=2; |
| try { dbg.enterSubRule(80); |
| try { dbg.enterDecision(80, decisionCanBacktrack[80]); |
| |
| int LA80_0 = input.LA(1); |
| |
| if ( (LA80_0==LPAREN) ) { |
| alt80=1; |
| } |
| } finally {dbg.exitDecision(80);} |
| |
| switch (alt80) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:721:13: '(' ( elementValuePairs | elementValue )? ')' |
| { |
| dbg.location(721,13); |
| match(input,LPAREN,FOLLOW_LPAREN_in_annotation3375); if (state.failed) return ; |
| dbg.location(722,19); |
| // src/com/google/doclava/parser/Java.g:722:19: ( elementValuePairs | elementValue )? |
| int alt79=3; |
| try { dbg.enterSubRule(79); |
| try { dbg.enterDecision(79, decisionCanBacktrack[79]); |
| |
| int LA79_0 = input.LA(1); |
| |
| if ( (LA79_0==IDENTIFIER) ) { |
| int LA79_1 = input.LA(2); |
| |
| if ( (LA79_1==EQ) ) { |
| alt79=1; |
| } |
| else if ( (LA79_1==INSTANCEOF||(LA79_1>=LPAREN && LA79_1<=RPAREN)||LA79_1==LBRACKET||LA79_1==DOT||LA79_1==QUES||(LA79_1>=EQEQ && LA79_1<=PERCENT)||(LA79_1>=BANGEQ && LA79_1<=LT)) ) { |
| alt79=2; |
| } |
| } |
| else if ( ((LA79_0>=INTLITERAL && LA79_0<=NULL)||LA79_0==BOOLEAN||LA79_0==BYTE||LA79_0==CHAR||LA79_0==DOUBLE||LA79_0==FLOAT||LA79_0==INT||LA79_0==LONG||LA79_0==NEW||LA79_0==SHORT||LA79_0==SUPER||LA79_0==THIS||LA79_0==VOID||LA79_0==LPAREN||LA79_0==LBRACE||(LA79_0>=BANG && LA79_0<=TILDE)||(LA79_0>=PLUSPLUS && LA79_0<=SUB)||LA79_0==MONKEYS_AT) ) { |
| alt79=2; |
| } |
| } finally {dbg.exitDecision(79);} |
| |
| switch (alt79) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:722:23: elementValuePairs |
| { |
| dbg.location(722,23); |
| pushFollow(FOLLOW_elementValuePairs_in_annotation3399); |
| elementValuePairs(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:723:23: elementValue |
| { |
| dbg.location(723,23); |
| pushFollow(FOLLOW_elementValue_in_annotation3423); |
| elementValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(79);} |
| |
| dbg.location(725,13); |
| match(input,RPAREN,FOLLOW_RPAREN_in_annotation3458); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(80);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 45, annotation_StartIndex); } |
| } |
| dbg.location(727, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotation"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotation" |
| |
| |
| // $ANTLR start "elementValuePairs" |
| // src/com/google/doclava/parser/Java.g:729:1: elementValuePairs : elementValuePair ( ',' elementValuePair )* ; |
| public final void elementValuePairs() throws RecognitionException { |
| int elementValuePairs_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "elementValuePairs"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(729, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:730:5: ( elementValuePair ( ',' elementValuePair )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:730:9: elementValuePair ( ',' elementValuePair )* |
| { |
| dbg.location(730,9); |
| pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3488); |
| elementValuePair(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(731,9); |
| // src/com/google/doclava/parser/Java.g:731:9: ( ',' elementValuePair )* |
| try { dbg.enterSubRule(81); |
| |
| loop81: |
| do { |
| int alt81=2; |
| try { dbg.enterDecision(81, decisionCanBacktrack[81]); |
| |
| int LA81_0 = input.LA(1); |
| |
| if ( (LA81_0==COMMA) ) { |
| alt81=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(81);} |
| |
| switch (alt81) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:731:10: ',' elementValuePair |
| { |
| dbg.location(731,10); |
| match(input,COMMA,FOLLOW_COMMA_in_elementValuePairs3499); if (state.failed) return ; |
| dbg.location(731,14); |
| pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3501); |
| elementValuePair(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop81; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(81);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 46, elementValuePairs_StartIndex); } |
| } |
| dbg.location(733, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "elementValuePairs"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "elementValuePairs" |
| |
| |
| // $ANTLR start "elementValuePair" |
| // src/com/google/doclava/parser/Java.g:735:1: elementValuePair : IDENTIFIER '=' elementValue ; |
| public final void elementValuePair() throws RecognitionException { |
| int elementValuePair_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "elementValuePair"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(735, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:736:5: ( IDENTIFIER '=' elementValue ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:736:9: IDENTIFIER '=' elementValue |
| { |
| dbg.location(736,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_elementValuePair3531); if (state.failed) return ; |
| dbg.location(736,20); |
| match(input,EQ,FOLLOW_EQ_in_elementValuePair3533); if (state.failed) return ; |
| dbg.location(736,24); |
| pushFollow(FOLLOW_elementValue_in_elementValuePair3535); |
| elementValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 47, elementValuePair_StartIndex); } |
| } |
| dbg.location(737, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "elementValuePair"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "elementValuePair" |
| |
| |
| // $ANTLR start "elementValue" |
| // src/com/google/doclava/parser/Java.g:739:1: elementValue : ( conditionalExpression | annotation | elementValueArrayInitializer ); |
| public final void elementValue() throws RecognitionException { |
| int elementValue_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "elementValue"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(739, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:740:5: ( conditionalExpression | annotation | elementValueArrayInitializer ) |
| int alt82=3; |
| try { dbg.enterDecision(82, decisionCanBacktrack[82]); |
| |
| switch ( input.LA(1) ) { |
| case IDENTIFIER: |
| case INTLITERAL: |
| case LONGLITERAL: |
| case FLOATLITERAL: |
| case DOUBLELITERAL: |
| case CHARLITERAL: |
| case STRINGLITERAL: |
| case TRUE: |
| case FALSE: |
| case NULL: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case VOID: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| case PLUSPLUS: |
| case SUBSUB: |
| case PLUS: |
| case SUB: |
| { |
| alt82=1; |
| } |
| break; |
| case MONKEYS_AT: |
| { |
| alt82=2; |
| } |
| break; |
| case LBRACE: |
| { |
| alt82=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 82, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } finally {dbg.exitDecision(82);} |
| |
| switch (alt82) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:740:9: conditionalExpression |
| { |
| dbg.location(740,9); |
| pushFollow(FOLLOW_conditionalExpression_in_elementValue3554); |
| conditionalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:741:9: annotation |
| { |
| dbg.location(741,9); |
| pushFollow(FOLLOW_annotation_in_elementValue3564); |
| annotation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:742:9: elementValueArrayInitializer |
| { |
| dbg.location(742,9); |
| pushFollow(FOLLOW_elementValueArrayInitializer_in_elementValue3574); |
| elementValueArrayInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 48, elementValue_StartIndex); } |
| } |
| dbg.location(743, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "elementValue"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "elementValue" |
| |
| |
| // $ANTLR start "elementValueArrayInitializer" |
| // src/com/google/doclava/parser/Java.g:745:1: elementValueArrayInitializer : '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ; |
| public final void elementValueArrayInitializer() throws RecognitionException { |
| int elementValueArrayInitializer_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "elementValueArrayInitializer"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(745, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:746:5: ( '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:746:9: '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' |
| { |
| dbg.location(746,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_elementValueArrayInitializer3593); if (state.failed) return ; |
| dbg.location(747,9); |
| // src/com/google/doclava/parser/Java.g:747:9: ( elementValue ( ',' elementValue )* )? |
| int alt84=2; |
| try { dbg.enterSubRule(84); |
| try { dbg.enterDecision(84, decisionCanBacktrack[84]); |
| |
| int LA84_0 = input.LA(1); |
| |
| if ( ((LA84_0>=IDENTIFIER && LA84_0<=NULL)||LA84_0==BOOLEAN||LA84_0==BYTE||LA84_0==CHAR||LA84_0==DOUBLE||LA84_0==FLOAT||LA84_0==INT||LA84_0==LONG||LA84_0==NEW||LA84_0==SHORT||LA84_0==SUPER||LA84_0==THIS||LA84_0==VOID||LA84_0==LPAREN||LA84_0==LBRACE||(LA84_0>=BANG && LA84_0<=TILDE)||(LA84_0>=PLUSPLUS && LA84_0<=SUB)||LA84_0==MONKEYS_AT) ) { |
| alt84=1; |
| } |
| } finally {dbg.exitDecision(84);} |
| |
| switch (alt84) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:747:10: elementValue ( ',' elementValue )* |
| { |
| dbg.location(747,10); |
| pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3604); |
| elementValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(748,13); |
| // src/com/google/doclava/parser/Java.g:748:13: ( ',' elementValue )* |
| try { dbg.enterSubRule(83); |
| |
| loop83: |
| do { |
| int alt83=2; |
| try { dbg.enterDecision(83, decisionCanBacktrack[83]); |
| |
| int LA83_0 = input.LA(1); |
| |
| if ( (LA83_0==COMMA) ) { |
| int LA83_1 = input.LA(2); |
| |
| if ( ((LA83_1>=IDENTIFIER && LA83_1<=NULL)||LA83_1==BOOLEAN||LA83_1==BYTE||LA83_1==CHAR||LA83_1==DOUBLE||LA83_1==FLOAT||LA83_1==INT||LA83_1==LONG||LA83_1==NEW||LA83_1==SHORT||LA83_1==SUPER||LA83_1==THIS||LA83_1==VOID||LA83_1==LPAREN||LA83_1==LBRACE||(LA83_1>=BANG && LA83_1<=TILDE)||(LA83_1>=PLUSPLUS && LA83_1<=SUB)||LA83_1==MONKEYS_AT) ) { |
| alt83=1; |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(83);} |
| |
| switch (alt83) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:748:14: ',' elementValue |
| { |
| dbg.location(748,14); |
| match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3619); if (state.failed) return ; |
| dbg.location(748,18); |
| pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3621); |
| elementValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop83; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(83);} |
| |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(84);} |
| |
| dbg.location(750,12); |
| // src/com/google/doclava/parser/Java.g:750:12: ( ',' )? |
| int alt85=2; |
| try { dbg.enterSubRule(85); |
| try { dbg.enterDecision(85, decisionCanBacktrack[85]); |
| |
| int LA85_0 = input.LA(1); |
| |
| if ( (LA85_0==COMMA) ) { |
| alt85=1; |
| } |
| } finally {dbg.exitDecision(85);} |
| |
| switch (alt85) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:750:13: ',' |
| { |
| dbg.location(750,13); |
| match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3650); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(85);} |
| |
| dbg.location(750,19); |
| match(input,RBRACE,FOLLOW_RBRACE_in_elementValueArrayInitializer3654); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 49, elementValueArrayInitializer_StartIndex); } |
| } |
| dbg.location(751, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "elementValueArrayInitializer"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "elementValueArrayInitializer" |
| |
| |
| // $ANTLR start "annotationTypeDeclaration" |
| // src/com/google/doclava/parser/Java.g:754:1: annotationTypeDeclaration : modifiers '@' 'interface' IDENTIFIER annotationTypeBody ; |
| public final void annotationTypeDeclaration() throws RecognitionException { |
| int annotationTypeDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotationTypeDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(754, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:758:5: ( modifiers '@' 'interface' IDENTIFIER annotationTypeBody ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:758:9: modifiers '@' 'interface' IDENTIFIER annotationTypeBody |
| { |
| dbg.location(758,9); |
| pushFollow(FOLLOW_modifiers_in_annotationTypeDeclaration3676); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(758,19); |
| match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678); if (state.failed) return ; |
| dbg.location(759,9); |
| match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationTypeDeclaration3688); if (state.failed) return ; |
| dbg.location(760,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698); if (state.failed) return ; |
| dbg.location(761,9); |
| pushFollow(FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708); |
| annotationTypeBody(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 50, annotationTypeDeclaration_StartIndex); } |
| } |
| dbg.location(762, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotationTypeDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotationTypeDeclaration" |
| |
| |
| // $ANTLR start "annotationTypeBody" |
| // src/com/google/doclava/parser/Java.g:765:1: annotationTypeBody : '{' ( annotationTypeElementDeclaration )* '}' ; |
| public final void annotationTypeBody() throws RecognitionException { |
| int annotationTypeBody_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotationTypeBody"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(765, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:766:5: ( '{' ( annotationTypeElementDeclaration )* '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:766:9: '{' ( annotationTypeElementDeclaration )* '}' |
| { |
| dbg.location(766,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_annotationTypeBody3728); if (state.failed) return ; |
| dbg.location(767,9); |
| // src/com/google/doclava/parser/Java.g:767:9: ( annotationTypeElementDeclaration )* |
| try { dbg.enterSubRule(86); |
| |
| loop86: |
| do { |
| int alt86=2; |
| try { dbg.enterDecision(86, decisionCanBacktrack[86]); |
| |
| int LA86_0 = input.LA(1); |
| |
| if ( (LA86_0==IDENTIFIER||LA86_0==ABSTRACT||LA86_0==BOOLEAN||LA86_0==BYTE||(LA86_0>=CHAR && LA86_0<=CLASS)||LA86_0==DOUBLE||LA86_0==ENUM||LA86_0==FINAL||LA86_0==FLOAT||(LA86_0>=INT && LA86_0<=NATIVE)||(LA86_0>=PRIVATE && LA86_0<=PUBLIC)||(LA86_0>=SHORT && LA86_0<=STRICTFP)||LA86_0==SYNCHRONIZED||LA86_0==TRANSIENT||(LA86_0>=VOID && LA86_0<=VOLATILE)||LA86_0==SEMI||LA86_0==MONKEYS_AT||LA86_0==LT) ) { |
| alt86=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(86);} |
| |
| switch (alt86) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:767:10: annotationTypeElementDeclaration |
| { |
| dbg.location(767,10); |
| pushFollow(FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739); |
| annotationTypeElementDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop86; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(86);} |
| |
| dbg.location(769,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_annotationTypeBody3760); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 51, annotationTypeBody_StartIndex); } |
| } |
| dbg.location(770, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotationTypeBody"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotationTypeBody" |
| |
| |
| // $ANTLR start "annotationTypeElementDeclaration" |
| // src/com/google/doclava/parser/Java.g:772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' ); |
| public final void annotationTypeElementDeclaration() throws RecognitionException { |
| int annotationTypeElementDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotationTypeElementDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(772, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:776:5: ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' ) |
| int alt87=7; |
| try { dbg.enterDecision(87, decisionCanBacktrack[87]); |
| |
| try { |
| isCyclicDecision = true; |
| alt87 = dfa87.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(87);} |
| |
| switch (alt87) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration |
| { |
| dbg.location(776,9); |
| pushFollow(FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781); |
| annotationMethodDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration |
| { |
| dbg.location(777,9); |
| pushFollow(FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791); |
| interfaceFieldDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration |
| { |
| dbg.location(778,9); |
| pushFollow(FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801); |
| normalClassDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration |
| { |
| dbg.location(779,9); |
| pushFollow(FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811); |
| normalInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration |
| { |
| dbg.location(780,9); |
| pushFollow(FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821); |
| enumDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 6 : |
| dbg.enterAlt(6); |
| |
| // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration |
| { |
| dbg.location(781,9); |
| pushFollow(FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831); |
| annotationTypeDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 7 : |
| dbg.enterAlt(7); |
| |
| // src/com/google/doclava/parser/Java.g:782:9: ';' |
| { |
| dbg.location(782,9); |
| match(input,SEMI,FOLLOW_SEMI_in_annotationTypeElementDeclaration3841); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 52, annotationTypeElementDeclaration_StartIndex); } |
| } |
| dbg.location(783, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotationTypeElementDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotationTypeElementDeclaration" |
| |
| |
| // $ANTLR start "annotationMethodDeclaration" |
| // src/com/google/doclava/parser/Java.g:785:1: annotationMethodDeclaration : modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' ; |
| public final void annotationMethodDeclaration() throws RecognitionException { |
| int annotationMethodDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotationMethodDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(785, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:786:5: ( modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:786:9: modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' |
| { |
| dbg.location(786,9); |
| pushFollow(FOLLOW_modifiers_in_annotationMethodDeclaration3860); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(786,19); |
| pushFollow(FOLLOW_type_in_annotationMethodDeclaration3862); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(786,24); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864); if (state.failed) return ; |
| dbg.location(787,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_annotationMethodDeclaration3874); if (state.failed) return ; |
| dbg.location(787,13); |
| match(input,RPAREN,FOLLOW_RPAREN_in_annotationMethodDeclaration3876); if (state.failed) return ; |
| dbg.location(787,17); |
| // src/com/google/doclava/parser/Java.g:787:17: ( 'default' elementValue )? |
| int alt88=2; |
| try { dbg.enterSubRule(88); |
| try { dbg.enterDecision(88, decisionCanBacktrack[88]); |
| |
| int LA88_0 = input.LA(1); |
| |
| if ( (LA88_0==DEFAULT) ) { |
| alt88=1; |
| } |
| } finally {dbg.exitDecision(88);} |
| |
| switch (alt88) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:787:18: 'default' elementValue |
| { |
| dbg.location(787,18); |
| match(input,DEFAULT,FOLLOW_DEFAULT_in_annotationMethodDeclaration3879); if (state.failed) return ; |
| dbg.location(787,28); |
| pushFollow(FOLLOW_elementValue_in_annotationMethodDeclaration3881); |
| elementValue(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(88);} |
| |
| dbg.location(789,9); |
| match(input,SEMI,FOLLOW_SEMI_in_annotationMethodDeclaration3910); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 53, annotationMethodDeclaration_StartIndex); } |
| } |
| dbg.location(790, 9); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotationMethodDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotationMethodDeclaration" |
| |
| |
| // $ANTLR start "block" |
| // src/com/google/doclava/parser/Java.g:792:1: block : '{' ( blockStatement )* '}' ; |
| public final void block() throws RecognitionException { |
| int block_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "block"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(792, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:793:5: ( '{' ( blockStatement )* '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:793:9: '{' ( blockStatement )* '}' |
| { |
| dbg.location(793,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_block3933); if (state.failed) return ; |
| dbg.location(794,9); |
| // src/com/google/doclava/parser/Java.g:794:9: ( blockStatement )* |
| try { dbg.enterSubRule(89); |
| |
| loop89: |
| do { |
| int alt89=2; |
| try { dbg.enterDecision(89, decisionCanBacktrack[89]); |
| |
| int LA89_0 = input.LA(1); |
| |
| if ( ((LA89_0>=IDENTIFIER && LA89_0<=NULL)||(LA89_0>=ABSTRACT && LA89_0<=BYTE)||(LA89_0>=CHAR && LA89_0<=CLASS)||LA89_0==CONTINUE||(LA89_0>=DO && LA89_0<=DOUBLE)||LA89_0==ENUM||LA89_0==FINAL||(LA89_0>=FLOAT && LA89_0<=FOR)||LA89_0==IF||(LA89_0>=INT && LA89_0<=NEW)||(LA89_0>=PRIVATE && LA89_0<=THROW)||(LA89_0>=TRANSIENT && LA89_0<=LPAREN)||LA89_0==LBRACE||LA89_0==SEMI||(LA89_0>=BANG && LA89_0<=TILDE)||(LA89_0>=PLUSPLUS && LA89_0<=SUB)||LA89_0==MONKEYS_AT||LA89_0==LT) ) { |
| alt89=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(89);} |
| |
| switch (alt89) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:794:10: blockStatement |
| { |
| dbg.location(794,10); |
| pushFollow(FOLLOW_blockStatement_in_block3944); |
| blockStatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop89; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(89);} |
| |
| dbg.location(796,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_block3965); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 54, block_StartIndex); } |
| } |
| dbg.location(797, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "block"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "block" |
| |
| |
| // $ANTLR start "blockStatement" |
| // src/com/google/doclava/parser/Java.g:823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement ); |
| public final void blockStatement() throws RecognitionException { |
| int blockStatement_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "blockStatement"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(823, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:824:5: ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement ) |
| int alt90=3; |
| try { dbg.enterDecision(90, decisionCanBacktrack[90]); |
| |
| try { |
| isCyclicDecision = true; |
| alt90 = dfa90.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(90);} |
| |
| switch (alt90) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement |
| { |
| dbg.location(824,9); |
| pushFollow(FOLLOW_localVariableDeclarationStatement_in_blockStatement3986); |
| localVariableDeclarationStatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration |
| { |
| dbg.location(825,9); |
| pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996); |
| classOrInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:826:9: statement |
| { |
| dbg.location(826,9); |
| pushFollow(FOLLOW_statement_in_blockStatement4006); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 55, blockStatement_StartIndex); } |
| } |
| dbg.location(827, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "blockStatement"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "blockStatement" |
| |
| |
| // $ANTLR start "localVariableDeclarationStatement" |
| // src/com/google/doclava/parser/Java.g:830:1: localVariableDeclarationStatement : localVariableDeclaration ';' ; |
| public final void localVariableDeclarationStatement() throws RecognitionException { |
| int localVariableDeclarationStatement_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "localVariableDeclarationStatement"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(830, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:831:5: ( localVariableDeclaration ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:831:9: localVariableDeclaration ';' |
| { |
| dbg.location(831,9); |
| pushFollow(FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026); |
| localVariableDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(832,9); |
| match(input,SEMI,FOLLOW_SEMI_in_localVariableDeclarationStatement4036); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 56, localVariableDeclarationStatement_StartIndex); } |
| } |
| dbg.location(833, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "localVariableDeclarationStatement"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "localVariableDeclarationStatement" |
| |
| |
| // $ANTLR start "localVariableDeclaration" |
| // src/com/google/doclava/parser/Java.g:835:1: localVariableDeclaration : variableModifiers type variableDeclarator ( ',' variableDeclarator )* ; |
| public final void localVariableDeclaration() throws RecognitionException { |
| int localVariableDeclaration_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "localVariableDeclaration"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(835, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:836:5: ( variableModifiers type variableDeclarator ( ',' variableDeclarator )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:836:9: variableModifiers type variableDeclarator ( ',' variableDeclarator )* |
| { |
| dbg.location(836,9); |
| pushFollow(FOLLOW_variableModifiers_in_localVariableDeclaration4055); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(836,27); |
| pushFollow(FOLLOW_type_in_localVariableDeclaration4057); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(837,9); |
| pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4067); |
| variableDeclarator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(838,9); |
| // src/com/google/doclava/parser/Java.g:838:9: ( ',' variableDeclarator )* |
| try { dbg.enterSubRule(91); |
| |
| loop91: |
| do { |
| int alt91=2; |
| try { dbg.enterDecision(91, decisionCanBacktrack[91]); |
| |
| int LA91_0 = input.LA(1); |
| |
| if ( (LA91_0==COMMA) ) { |
| alt91=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(91);} |
| |
| switch (alt91) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:838:10: ',' variableDeclarator |
| { |
| dbg.location(838,10); |
| match(input,COMMA,FOLLOW_COMMA_in_localVariableDeclaration4078); if (state.failed) return ; |
| dbg.location(838,14); |
| pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4080); |
| variableDeclarator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop91; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(91);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 57, localVariableDeclaration_StartIndex); } |
| } |
| dbg.location(840, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "localVariableDeclaration"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "localVariableDeclaration" |
| |
| |
| // $ANTLR start "statement" |
| // src/com/google/doclava/parser/Java.g:842:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' ); |
| public final void statement() throws RecognitionException { |
| int statement_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "statement"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(842, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:843:5: ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' ) |
| int alt98=17; |
| try { dbg.enterDecision(98, decisionCanBacktrack[98]); |
| |
| try { |
| isCyclicDecision = true; |
| alt98 = dfa98.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(98);} |
| |
| switch (alt98) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:843:9: block |
| { |
| dbg.location(843,9); |
| pushFollow(FOLLOW_block_in_statement4110); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';' |
| { |
| dbg.location(845,9); |
| // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:845:10: 'assert' |
| { |
| dbg.location(845,10); |
| match(input,ASSERT,FOLLOW_ASSERT_in_statement4122); if (state.failed) return ; |
| |
| } |
| |
| dbg.location(847,9); |
| pushFollow(FOLLOW_expression_in_statement4142); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(847,20); |
| // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )? |
| int alt92=2; |
| try { dbg.enterSubRule(92); |
| try { dbg.enterDecision(92, decisionCanBacktrack[92]); |
| |
| int LA92_0 = input.LA(1); |
| |
| if ( (LA92_0==COLON) ) { |
| alt92=1; |
| } |
| } finally {dbg.exitDecision(92);} |
| |
| switch (alt92) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:847:21: ':' expression |
| { |
| dbg.location(847,21); |
| match(input,COLON,FOLLOW_COLON_in_statement4145); if (state.failed) return ; |
| dbg.location(847,25); |
| pushFollow(FOLLOW_expression_in_statement4147); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(92);} |
| |
| dbg.location(847,38); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4151); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';' |
| { |
| dbg.location(848,9); |
| match(input,ASSERT,FOLLOW_ASSERT_in_statement4161); if (state.failed) return ; |
| dbg.location(848,19); |
| pushFollow(FOLLOW_expression_in_statement4164); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(848,30); |
| // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )? |
| int alt93=2; |
| try { dbg.enterSubRule(93); |
| try { dbg.enterDecision(93, decisionCanBacktrack[93]); |
| |
| int LA93_0 = input.LA(1); |
| |
| if ( (LA93_0==COLON) ) { |
| alt93=1; |
| } |
| } finally {dbg.exitDecision(93);} |
| |
| switch (alt93) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:848:31: ':' expression |
| { |
| dbg.location(848,31); |
| match(input,COLON,FOLLOW_COLON_in_statement4167); if (state.failed) return ; |
| dbg.location(848,35); |
| pushFollow(FOLLOW_expression_in_statement4169); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(93);} |
| |
| dbg.location(848,48); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4173); if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:849:9: 'if' parExpression statement ( 'else' statement )? |
| { |
| dbg.location(849,9); |
| match(input,IF,FOLLOW_IF_in_statement4183); if (state.failed) return ; |
| dbg.location(849,14); |
| pushFollow(FOLLOW_parExpression_in_statement4185); |
| parExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(849,28); |
| pushFollow(FOLLOW_statement_in_statement4187); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(849,38); |
| // src/com/google/doclava/parser/Java.g:849:38: ( 'else' statement )? |
| int alt94=2; |
| try { dbg.enterSubRule(94); |
| try { dbg.enterDecision(94, decisionCanBacktrack[94]); |
| |
| int LA94_0 = input.LA(1); |
| |
| if ( (LA94_0==ELSE) ) { |
| int LA94_1 = input.LA(2); |
| |
| if ( (synpred133_Java()) ) { |
| alt94=1; |
| } |
| } |
| } finally {dbg.exitDecision(94);} |
| |
| switch (alt94) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:849:39: 'else' statement |
| { |
| dbg.location(849,39); |
| match(input,ELSE,FOLLOW_ELSE_in_statement4190); if (state.failed) return ; |
| dbg.location(849,46); |
| pushFollow(FOLLOW_statement_in_statement4192); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(94);} |
| |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:850:9: forstatement |
| { |
| dbg.location(850,9); |
| pushFollow(FOLLOW_forstatement_in_statement4204); |
| forstatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 6 : |
| dbg.enterAlt(6); |
| |
| // src/com/google/doclava/parser/Java.g:851:9: 'while' parExpression statement |
| { |
| dbg.location(851,9); |
| match(input,WHILE,FOLLOW_WHILE_in_statement4214); if (state.failed) return ; |
| dbg.location(851,17); |
| pushFollow(FOLLOW_parExpression_in_statement4216); |
| parExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(851,31); |
| pushFollow(FOLLOW_statement_in_statement4218); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 7 : |
| dbg.enterAlt(7); |
| |
| // src/com/google/doclava/parser/Java.g:852:9: 'do' statement 'while' parExpression ';' |
| { |
| dbg.location(852,9); |
| match(input,DO,FOLLOW_DO_in_statement4228); if (state.failed) return ; |
| dbg.location(852,14); |
| pushFollow(FOLLOW_statement_in_statement4230); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(852,24); |
| match(input,WHILE,FOLLOW_WHILE_in_statement4232); if (state.failed) return ; |
| dbg.location(852,32); |
| pushFollow(FOLLOW_parExpression_in_statement4234); |
| parExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(852,46); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4236); if (state.failed) return ; |
| |
| } |
| break; |
| case 8 : |
| dbg.enterAlt(8); |
| |
| // src/com/google/doclava/parser/Java.g:853:9: trystatement |
| { |
| dbg.location(853,9); |
| pushFollow(FOLLOW_trystatement_in_statement4246); |
| trystatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 9 : |
| dbg.enterAlt(9); |
| |
| // src/com/google/doclava/parser/Java.g:854:9: 'switch' parExpression '{' switchBlockStatementGroups '}' |
| { |
| dbg.location(854,9); |
| match(input,SWITCH,FOLLOW_SWITCH_in_statement4256); if (state.failed) return ; |
| dbg.location(854,18); |
| pushFollow(FOLLOW_parExpression_in_statement4258); |
| parExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(854,32); |
| match(input,LBRACE,FOLLOW_LBRACE_in_statement4260); if (state.failed) return ; |
| dbg.location(854,36); |
| pushFollow(FOLLOW_switchBlockStatementGroups_in_statement4262); |
| switchBlockStatementGroups(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(854,63); |
| match(input,RBRACE,FOLLOW_RBRACE_in_statement4264); if (state.failed) return ; |
| |
| } |
| break; |
| case 10 : |
| dbg.enterAlt(10); |
| |
| // src/com/google/doclava/parser/Java.g:855:9: 'synchronized' parExpression block |
| { |
| dbg.location(855,9); |
| match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_statement4274); if (state.failed) return ; |
| dbg.location(855,24); |
| pushFollow(FOLLOW_parExpression_in_statement4276); |
| parExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(855,38); |
| pushFollow(FOLLOW_block_in_statement4278); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 11 : |
| dbg.enterAlt(11); |
| |
| // src/com/google/doclava/parser/Java.g:856:9: 'return' ( expression )? ';' |
| { |
| dbg.location(856,9); |
| match(input,RETURN,FOLLOW_RETURN_in_statement4288); if (state.failed) return ; |
| dbg.location(856,18); |
| // src/com/google/doclava/parser/Java.g:856:18: ( expression )? |
| int alt95=2; |
| try { dbg.enterSubRule(95); |
| try { dbg.enterDecision(95, decisionCanBacktrack[95]); |
| |
| int LA95_0 = input.LA(1); |
| |
| if ( ((LA95_0>=IDENTIFIER && LA95_0<=NULL)||LA95_0==BOOLEAN||LA95_0==BYTE||LA95_0==CHAR||LA95_0==DOUBLE||LA95_0==FLOAT||LA95_0==INT||LA95_0==LONG||LA95_0==NEW||LA95_0==SHORT||LA95_0==SUPER||LA95_0==THIS||LA95_0==VOID||LA95_0==LPAREN||(LA95_0>=BANG && LA95_0<=TILDE)||(LA95_0>=PLUSPLUS && LA95_0<=SUB)) ) { |
| alt95=1; |
| } |
| } finally {dbg.exitDecision(95);} |
| |
| switch (alt95) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:856:19: expression |
| { |
| dbg.location(856,19); |
| pushFollow(FOLLOW_expression_in_statement4291); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(95);} |
| |
| dbg.location(856,33); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4296); if (state.failed) return ; |
| |
| } |
| break; |
| case 12 : |
| dbg.enterAlt(12); |
| |
| // src/com/google/doclava/parser/Java.g:857:9: 'throw' expression ';' |
| { |
| dbg.location(857,9); |
| match(input,THROW,FOLLOW_THROW_in_statement4306); if (state.failed) return ; |
| dbg.location(857,17); |
| pushFollow(FOLLOW_expression_in_statement4308); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(857,28); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4310); if (state.failed) return ; |
| |
| } |
| break; |
| case 13 : |
| dbg.enterAlt(13); |
| |
| // src/com/google/doclava/parser/Java.g:858:9: 'break' ( IDENTIFIER )? ';' |
| { |
| dbg.location(858,9); |
| match(input,BREAK,FOLLOW_BREAK_in_statement4320); if (state.failed) return ; |
| dbg.location(859,13); |
| // src/com/google/doclava/parser/Java.g:859:13: ( IDENTIFIER )? |
| int alt96=2; |
| try { dbg.enterSubRule(96); |
| try { dbg.enterDecision(96, decisionCanBacktrack[96]); |
| |
| int LA96_0 = input.LA(1); |
| |
| if ( (LA96_0==IDENTIFIER) ) { |
| alt96=1; |
| } |
| } finally {dbg.exitDecision(96);} |
| |
| switch (alt96) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:859:14: IDENTIFIER |
| { |
| dbg.location(859,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4335); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(96);} |
| |
| dbg.location(860,16); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4352); if (state.failed) return ; |
| |
| } |
| break; |
| case 14 : |
| dbg.enterAlt(14); |
| |
| // src/com/google/doclava/parser/Java.g:861:9: 'continue' ( IDENTIFIER )? ';' |
| { |
| dbg.location(861,9); |
| match(input,CONTINUE,FOLLOW_CONTINUE_in_statement4362); if (state.failed) return ; |
| dbg.location(862,13); |
| // src/com/google/doclava/parser/Java.g:862:13: ( IDENTIFIER )? |
| int alt97=2; |
| try { dbg.enterSubRule(97); |
| try { dbg.enterDecision(97, decisionCanBacktrack[97]); |
| |
| int LA97_0 = input.LA(1); |
| |
| if ( (LA97_0==IDENTIFIER) ) { |
| alt97=1; |
| } |
| } finally {dbg.exitDecision(97);} |
| |
| switch (alt97) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:862:14: IDENTIFIER |
| { |
| dbg.location(862,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4377); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(97);} |
| |
| dbg.location(863,16); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4394); if (state.failed) return ; |
| |
| } |
| break; |
| case 15 : |
| dbg.enterAlt(15); |
| |
| // src/com/google/doclava/parser/Java.g:864:9: expression ';' |
| { |
| dbg.location(864,9); |
| pushFollow(FOLLOW_expression_in_statement4404); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(864,21); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4407); if (state.failed) return ; |
| |
| } |
| break; |
| case 16 : |
| dbg.enterAlt(16); |
| |
| // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement |
| { |
| dbg.location(865,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4417); if (state.failed) return ; |
| dbg.location(865,20); |
| match(input,COLON,FOLLOW_COLON_in_statement4419); if (state.failed) return ; |
| dbg.location(865,24); |
| pushFollow(FOLLOW_statement_in_statement4421); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 17 : |
| dbg.enterAlt(17); |
| |
| // src/com/google/doclava/parser/Java.g:866:9: ';' |
| { |
| dbg.location(866,9); |
| match(input,SEMI,FOLLOW_SEMI_in_statement4431); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 58, statement_StartIndex); } |
| } |
| dbg.location(868, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "statement"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "statement" |
| |
| |
| // $ANTLR start "switchBlockStatementGroups" |
| // src/com/google/doclava/parser/Java.g:870:1: switchBlockStatementGroups : ( switchBlockStatementGroup )* ; |
| public final void switchBlockStatementGroups() throws RecognitionException { |
| int switchBlockStatementGroups_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroups"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(870, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:871:5: ( ( switchBlockStatementGroup )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )* |
| { |
| dbg.location(871,9); |
| // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )* |
| try { dbg.enterSubRule(99); |
| |
| loop99: |
| do { |
| int alt99=2; |
| try { dbg.enterDecision(99, decisionCanBacktrack[99]); |
| |
| int LA99_0 = input.LA(1); |
| |
| if ( (LA99_0==CASE||LA99_0==DEFAULT) ) { |
| alt99=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(99);} |
| |
| switch (alt99) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:871:10: switchBlockStatementGroup |
| { |
| dbg.location(871,10); |
| pushFollow(FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452); |
| switchBlockStatementGroup(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop99; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(99);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 59, switchBlockStatementGroups_StartIndex); } |
| } |
| dbg.location(872, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroups"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "switchBlockStatementGroups" |
| |
| |
| // $ANTLR start "switchBlockStatementGroup" |
| // src/com/google/doclava/parser/Java.g:874:1: switchBlockStatementGroup : switchLabel ( blockStatement )* ; |
| public final void switchBlockStatementGroup() throws RecognitionException { |
| int switchBlockStatementGroup_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroup"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(874, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:875:5: ( switchLabel ( blockStatement )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:876:9: switchLabel ( blockStatement )* |
| { |
| dbg.location(876,9); |
| pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup4480); |
| switchLabel(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(877,9); |
| // src/com/google/doclava/parser/Java.g:877:9: ( blockStatement )* |
| try { dbg.enterSubRule(100); |
| |
| loop100: |
| do { |
| int alt100=2; |
| try { dbg.enterDecision(100, decisionCanBacktrack[100]); |
| |
| int LA100_0 = input.LA(1); |
| |
| if ( ((LA100_0>=IDENTIFIER && LA100_0<=NULL)||(LA100_0>=ABSTRACT && LA100_0<=BYTE)||(LA100_0>=CHAR && LA100_0<=CLASS)||LA100_0==CONTINUE||(LA100_0>=DO && LA100_0<=DOUBLE)||LA100_0==ENUM||LA100_0==FINAL||(LA100_0>=FLOAT && LA100_0<=FOR)||LA100_0==IF||(LA100_0>=INT && LA100_0<=NEW)||(LA100_0>=PRIVATE && LA100_0<=THROW)||(LA100_0>=TRANSIENT && LA100_0<=LPAREN)||LA100_0==LBRACE||LA100_0==SEMI||(LA100_0>=BANG && LA100_0<=TILDE)||(LA100_0>=PLUSPLUS && LA100_0<=SUB)||LA100_0==MONKEYS_AT||LA100_0==LT) ) { |
| alt100=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(100);} |
| |
| switch (alt100) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:877:10: blockStatement |
| { |
| dbg.location(877,10); |
| pushFollow(FOLLOW_blockStatement_in_switchBlockStatementGroup4491); |
| blockStatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop100; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(100);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 60, switchBlockStatementGroup_StartIndex); } |
| } |
| dbg.location(879, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroup"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "switchBlockStatementGroup" |
| |
| |
| // $ANTLR start "switchLabel" |
| // src/com/google/doclava/parser/Java.g:881:1: switchLabel : ( 'case' expression ':' | 'default' ':' ); |
| public final void switchLabel() throws RecognitionException { |
| int switchLabel_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "switchLabel"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(881, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:882:5: ( 'case' expression ':' | 'default' ':' ) |
| int alt101=2; |
| try { dbg.enterDecision(101, decisionCanBacktrack[101]); |
| |
| int LA101_0 = input.LA(1); |
| |
| if ( (LA101_0==CASE) ) { |
| alt101=1; |
| } |
| else if ( (LA101_0==DEFAULT) ) { |
| alt101=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 101, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(101);} |
| |
| switch (alt101) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:882:9: 'case' expression ':' |
| { |
| dbg.location(882,9); |
| match(input,CASE,FOLLOW_CASE_in_switchLabel4521); if (state.failed) return ; |
| dbg.location(882,16); |
| pushFollow(FOLLOW_expression_in_switchLabel4523); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(882,27); |
| match(input,COLON,FOLLOW_COLON_in_switchLabel4525); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:883:9: 'default' ':' |
| { |
| dbg.location(883,9); |
| match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel4535); if (state.failed) return ; |
| dbg.location(883,19); |
| match(input,COLON,FOLLOW_COLON_in_switchLabel4537); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 61, switchLabel_StartIndex); } |
| } |
| dbg.location(884, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "switchLabel"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "switchLabel" |
| |
| |
| // $ANTLR start "trystatement" |
| // src/com/google/doclava/parser/Java.g:887:1: trystatement : 'try' block ( catches 'finally' block | catches | 'finally' block ) ; |
| public final void trystatement() throws RecognitionException { |
| int trystatement_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "trystatement"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(887, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:888:5: ( 'try' block ( catches 'finally' block | catches | 'finally' block ) ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:888:9: 'try' block ( catches 'finally' block | catches | 'finally' block ) |
| { |
| dbg.location(888,9); |
| match(input,TRY,FOLLOW_TRY_in_trystatement4557); if (state.failed) return ; |
| dbg.location(888,15); |
| pushFollow(FOLLOW_block_in_trystatement4559); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(889,9); |
| // src/com/google/doclava/parser/Java.g:889:9: ( catches 'finally' block | catches | 'finally' block ) |
| int alt102=3; |
| try { dbg.enterSubRule(102); |
| try { dbg.enterDecision(102, decisionCanBacktrack[102]); |
| |
| int LA102_0 = input.LA(1); |
| |
| if ( (LA102_0==CATCH) ) { |
| int LA102_1 = input.LA(2); |
| |
| if ( (synpred153_Java()) ) { |
| alt102=1; |
| } |
| else if ( (synpred154_Java()) ) { |
| alt102=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 102, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else if ( (LA102_0==FINALLY) ) { |
| alt102=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 102, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(102);} |
| |
| switch (alt102) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block |
| { |
| dbg.location(889,13); |
| pushFollow(FOLLOW_catches_in_trystatement4573); |
| catches(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(889,21); |
| match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4575); if (state.failed) return ; |
| dbg.location(889,31); |
| pushFollow(FOLLOW_block_in_trystatement4577); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:890:13: catches |
| { |
| dbg.location(890,13); |
| pushFollow(FOLLOW_catches_in_trystatement4591); |
| catches(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:891:13: 'finally' block |
| { |
| dbg.location(891,13); |
| match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4605); if (state.failed) return ; |
| dbg.location(891,23); |
| pushFollow(FOLLOW_block_in_trystatement4607); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(102);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 62, trystatement_StartIndex); } |
| } |
| dbg.location(893, 6); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "trystatement"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "trystatement" |
| |
| |
| // $ANTLR start "catches" |
| // src/com/google/doclava/parser/Java.g:895:1: catches : catchClause ( catchClause )* ; |
| public final void catches() throws RecognitionException { |
| int catches_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "catches"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(895, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:896:5: ( catchClause ( catchClause )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:896:9: catchClause ( catchClause )* |
| { |
| dbg.location(896,9); |
| pushFollow(FOLLOW_catchClause_in_catches4637); |
| catchClause(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(897,9); |
| // src/com/google/doclava/parser/Java.g:897:9: ( catchClause )* |
| try { dbg.enterSubRule(103); |
| |
| loop103: |
| do { |
| int alt103=2; |
| try { dbg.enterDecision(103, decisionCanBacktrack[103]); |
| |
| int LA103_0 = input.LA(1); |
| |
| if ( (LA103_0==CATCH) ) { |
| alt103=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(103);} |
| |
| switch (alt103) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:897:10: catchClause |
| { |
| dbg.location(897,10); |
| pushFollow(FOLLOW_catchClause_in_catches4648); |
| catchClause(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop103; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(103);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 63, catches_StartIndex); } |
| } |
| dbg.location(899, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "catches"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "catches" |
| |
| |
| // $ANTLR start "catchClause" |
| // src/com/google/doclava/parser/Java.g:901:1: catchClause : 'catch' '(' formalParameter ')' block ; |
| public final void catchClause() throws RecognitionException { |
| int catchClause_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "catchClause"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(901, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:902:5: ( 'catch' '(' formalParameter ')' block ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:902:9: 'catch' '(' formalParameter ')' block |
| { |
| dbg.location(902,9); |
| match(input,CATCH,FOLLOW_CATCH_in_catchClause4678); if (state.failed) return ; |
| dbg.location(902,17); |
| match(input,LPAREN,FOLLOW_LPAREN_in_catchClause4680); if (state.failed) return ; |
| dbg.location(902,21); |
| pushFollow(FOLLOW_formalParameter_in_catchClause4682); |
| formalParameter(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(903,9); |
| match(input,RPAREN,FOLLOW_RPAREN_in_catchClause4692); if (state.failed) return ; |
| dbg.location(903,13); |
| pushFollow(FOLLOW_block_in_catchClause4694); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 64, catchClause_StartIndex); } |
| } |
| dbg.location(904, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "catchClause"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "catchClause" |
| |
| |
| // $ANTLR start "formalParameter" |
| // src/com/google/doclava/parser/Java.g:906:1: formalParameter : variableModifiers type IDENTIFIER ( '[' ']' )* ; |
| public final void formalParameter() throws RecognitionException { |
| int formalParameter_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "formalParameter"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(906, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:907:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:907:9: variableModifiers type IDENTIFIER ( '[' ']' )* |
| { |
| dbg.location(907,9); |
| pushFollow(FOLLOW_variableModifiers_in_formalParameter4713); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(907,27); |
| pushFollow(FOLLOW_type_in_formalParameter4715); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(907,32); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_formalParameter4717); if (state.failed) return ; |
| dbg.location(908,9); |
| // src/com/google/doclava/parser/Java.g:908:9: ( '[' ']' )* |
| try { dbg.enterSubRule(104); |
| |
| loop104: |
| do { |
| int alt104=2; |
| try { dbg.enterDecision(104, decisionCanBacktrack[104]); |
| |
| int LA104_0 = input.LA(1); |
| |
| if ( (LA104_0==LBRACKET) ) { |
| alt104=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(104);} |
| |
| switch (alt104) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:908:10: '[' ']' |
| { |
| dbg.location(908,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_formalParameter4728); if (state.failed) return ; |
| dbg.location(908,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_formalParameter4730); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop104; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(104);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 65, formalParameter_StartIndex); } |
| } |
| dbg.location(910, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "formalParameter"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "formalParameter" |
| |
| |
| // $ANTLR start "forstatement" |
| // src/com/google/doclava/parser/Java.g:912:1: forstatement : ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement ); |
| public final void forstatement() throws RecognitionException { |
| int forstatement_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "forstatement"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(912, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:913:5: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement ) |
| int alt108=2; |
| try { dbg.enterDecision(108, decisionCanBacktrack[108]); |
| |
| int LA108_0 = input.LA(1); |
| |
| if ( (LA108_0==FOR) ) { |
| int LA108_1 = input.LA(2); |
| |
| if ( (synpred157_Java()) ) { |
| alt108=1; |
| } |
| else if ( (true) ) { |
| alt108=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 108, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 108, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(108);} |
| |
| switch (alt108) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement |
| { |
| dbg.location(915,9); |
| match(input,FOR,FOLLOW_FOR_in_forstatement4775); if (state.failed) return ; |
| dbg.location(915,15); |
| match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4777); if (state.failed) return ; |
| dbg.location(915,19); |
| pushFollow(FOLLOW_variableModifiers_in_forstatement4779); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(915,37); |
| pushFollow(FOLLOW_type_in_forstatement4781); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(915,42); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forstatement4783); if (state.failed) return ; |
| dbg.location(915,53); |
| match(input,COLON,FOLLOW_COLON_in_forstatement4785); if (state.failed) return ; |
| dbg.location(916,9); |
| pushFollow(FOLLOW_expression_in_forstatement4795); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(916,20); |
| match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4797); if (state.failed) return ; |
| dbg.location(916,24); |
| pushFollow(FOLLOW_statement_in_forstatement4799); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:919:9: 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement |
| { |
| dbg.location(919,9); |
| match(input,FOR,FOLLOW_FOR_in_forstatement4819); if (state.failed) return ; |
| dbg.location(919,15); |
| match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4821); if (state.failed) return ; |
| dbg.location(920,17); |
| // src/com/google/doclava/parser/Java.g:920:17: ( forInit )? |
| int alt105=2; |
| try { dbg.enterSubRule(105); |
| try { dbg.enterDecision(105, decisionCanBacktrack[105]); |
| |
| int LA105_0 = input.LA(1); |
| |
| if ( ((LA105_0>=IDENTIFIER && LA105_0<=NULL)||LA105_0==BOOLEAN||LA105_0==BYTE||LA105_0==CHAR||LA105_0==DOUBLE||LA105_0==FINAL||LA105_0==FLOAT||LA105_0==INT||LA105_0==LONG||LA105_0==NEW||LA105_0==SHORT||LA105_0==SUPER||LA105_0==THIS||LA105_0==VOID||LA105_0==LPAREN||(LA105_0>=BANG && LA105_0<=TILDE)||(LA105_0>=PLUSPLUS && LA105_0<=SUB)||LA105_0==MONKEYS_AT) ) { |
| alt105=1; |
| } |
| } finally {dbg.exitDecision(105);} |
| |
| switch (alt105) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:920:18: forInit |
| { |
| dbg.location(920,18); |
| pushFollow(FOLLOW_forInit_in_forstatement4840); |
| forInit(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(105);} |
| |
| dbg.location(921,20); |
| match(input,SEMI,FOLLOW_SEMI_in_forstatement4861); if (state.failed) return ; |
| dbg.location(922,17); |
| // src/com/google/doclava/parser/Java.g:922:17: ( expression )? |
| int alt106=2; |
| try { dbg.enterSubRule(106); |
| try { dbg.enterDecision(106, decisionCanBacktrack[106]); |
| |
| int LA106_0 = input.LA(1); |
| |
| if ( ((LA106_0>=IDENTIFIER && LA106_0<=NULL)||LA106_0==BOOLEAN||LA106_0==BYTE||LA106_0==CHAR||LA106_0==DOUBLE||LA106_0==FLOAT||LA106_0==INT||LA106_0==LONG||LA106_0==NEW||LA106_0==SHORT||LA106_0==SUPER||LA106_0==THIS||LA106_0==VOID||LA106_0==LPAREN||(LA106_0>=BANG && LA106_0<=TILDE)||(LA106_0>=PLUSPLUS && LA106_0<=SUB)) ) { |
| alt106=1; |
| } |
| } finally {dbg.exitDecision(106);} |
| |
| switch (alt106) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:922:18: expression |
| { |
| dbg.location(922,18); |
| pushFollow(FOLLOW_expression_in_forstatement4880); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(106);} |
| |
| dbg.location(923,20); |
| match(input,SEMI,FOLLOW_SEMI_in_forstatement4901); if (state.failed) return ; |
| dbg.location(924,17); |
| // src/com/google/doclava/parser/Java.g:924:17: ( expressionList )? |
| int alt107=2; |
| try { dbg.enterSubRule(107); |
| try { dbg.enterDecision(107, decisionCanBacktrack[107]); |
| |
| int LA107_0 = input.LA(1); |
| |
| if ( ((LA107_0>=IDENTIFIER && LA107_0<=NULL)||LA107_0==BOOLEAN||LA107_0==BYTE||LA107_0==CHAR||LA107_0==DOUBLE||LA107_0==FLOAT||LA107_0==INT||LA107_0==LONG||LA107_0==NEW||LA107_0==SHORT||LA107_0==SUPER||LA107_0==THIS||LA107_0==VOID||LA107_0==LPAREN||(LA107_0>=BANG && LA107_0<=TILDE)||(LA107_0>=PLUSPLUS && LA107_0<=SUB)) ) { |
| alt107=1; |
| } |
| } finally {dbg.exitDecision(107);} |
| |
| switch (alt107) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:924:18: expressionList |
| { |
| dbg.location(924,18); |
| pushFollow(FOLLOW_expressionList_in_forstatement4920); |
| expressionList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(107);} |
| |
| dbg.location(925,20); |
| match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4941); if (state.failed) return ; |
| dbg.location(925,24); |
| pushFollow(FOLLOW_statement_in_forstatement4943); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 66, forstatement_StartIndex); } |
| } |
| dbg.location(926, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "forstatement"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "forstatement" |
| |
| |
| // $ANTLR start "forInit" |
| // src/com/google/doclava/parser/Java.g:928:1: forInit : ( localVariableDeclaration | expressionList ); |
| public final void forInit() throws RecognitionException { |
| int forInit_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "forInit"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(928, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:929:5: ( localVariableDeclaration | expressionList ) |
| int alt109=2; |
| try { dbg.enterDecision(109, decisionCanBacktrack[109]); |
| |
| try { |
| isCyclicDecision = true; |
| alt109 = dfa109.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(109);} |
| |
| switch (alt109) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration |
| { |
| dbg.location(929,9); |
| pushFollow(FOLLOW_localVariableDeclaration_in_forInit4962); |
| localVariableDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:930:9: expressionList |
| { |
| dbg.location(930,9); |
| pushFollow(FOLLOW_expressionList_in_forInit4972); |
| expressionList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 67, forInit_StartIndex); } |
| } |
| dbg.location(931, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "forInit"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "forInit" |
| |
| |
| // $ANTLR start "parExpression" |
| // src/com/google/doclava/parser/Java.g:933:1: parExpression : '(' expression ')' ; |
| public final void parExpression() throws RecognitionException { |
| int parExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "parExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(933, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:934:5: ( '(' expression ')' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:934:9: '(' expression ')' |
| { |
| dbg.location(934,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_parExpression4991); if (state.failed) return ; |
| dbg.location(934,13); |
| pushFollow(FOLLOW_expression_in_parExpression4993); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(934,24); |
| match(input,RPAREN,FOLLOW_RPAREN_in_parExpression4995); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 68, parExpression_StartIndex); } |
| } |
| dbg.location(935, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "parExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "parExpression" |
| |
| |
| // $ANTLR start "expressionList" |
| // src/com/google/doclava/parser/Java.g:937:1: expressionList : expression ( ',' expression )* ; |
| public final void expressionList() throws RecognitionException { |
| int expressionList_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "expressionList"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(937, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:938:5: ( expression ( ',' expression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:938:9: expression ( ',' expression )* |
| { |
| dbg.location(938,9); |
| pushFollow(FOLLOW_expression_in_expressionList5014); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(939,9); |
| // src/com/google/doclava/parser/Java.g:939:9: ( ',' expression )* |
| try { dbg.enterSubRule(110); |
| |
| loop110: |
| do { |
| int alt110=2; |
| try { dbg.enterDecision(110, decisionCanBacktrack[110]); |
| |
| int LA110_0 = input.LA(1); |
| |
| if ( (LA110_0==COMMA) ) { |
| alt110=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(110);} |
| |
| switch (alt110) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:939:10: ',' expression |
| { |
| dbg.location(939,10); |
| match(input,COMMA,FOLLOW_COMMA_in_expressionList5025); if (state.failed) return ; |
| dbg.location(939,14); |
| pushFollow(FOLLOW_expression_in_expressionList5027); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop110; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(110);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 69, expressionList_StartIndex); } |
| } |
| dbg.location(941, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "expressionList"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "expressionList" |
| |
| |
| // $ANTLR start "expression" |
| // src/com/google/doclava/parser/Java.g:944:1: expression : conditionalExpression ( assignmentOperator expression )? ; |
| public final void expression() throws RecognitionException { |
| int expression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "expression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(944, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:945:5: ( conditionalExpression ( assignmentOperator expression )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:945:9: conditionalExpression ( assignmentOperator expression )? |
| { |
| dbg.location(945,9); |
| pushFollow(FOLLOW_conditionalExpression_in_expression5058); |
| conditionalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(946,9); |
| // src/com/google/doclava/parser/Java.g:946:9: ( assignmentOperator expression )? |
| int alt111=2; |
| try { dbg.enterSubRule(111); |
| try { dbg.enterDecision(111, decisionCanBacktrack[111]); |
| |
| int LA111_0 = input.LA(1); |
| |
| if ( (LA111_0==EQ||(LA111_0>=PLUSEQ && LA111_0<=PERCENTEQ)||(LA111_0>=GT && LA111_0<=LT)) ) { |
| alt111=1; |
| } |
| } finally {dbg.exitDecision(111);} |
| |
| switch (alt111) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:946:10: assignmentOperator expression |
| { |
| dbg.location(946,10); |
| pushFollow(FOLLOW_assignmentOperator_in_expression5069); |
| assignmentOperator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(946,29); |
| pushFollow(FOLLOW_expression_in_expression5071); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(111);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 70, expression_StartIndex); } |
| } |
| dbg.location(948, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "expression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "expression" |
| |
| |
| // $ANTLR start "assignmentOperator" |
| // src/com/google/doclava/parser/Java.g:951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' ); |
| public final void assignmentOperator() throws RecognitionException { |
| int assignmentOperator_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "assignmentOperator"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(951, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:952:5: ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' ) |
| int alt112=12; |
| try { dbg.enterDecision(112, decisionCanBacktrack[112]); |
| |
| try { |
| isCyclicDecision = true; |
| alt112 = dfa112.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(112);} |
| |
| switch (alt112) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:952:9: '=' |
| { |
| dbg.location(952,9); |
| match(input,EQ,FOLLOW_EQ_in_assignmentOperator5102); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:953:9: '+=' |
| { |
| dbg.location(953,9); |
| match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignmentOperator5112); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:954:9: '-=' |
| { |
| dbg.location(954,9); |
| match(input,SUBEQ,FOLLOW_SUBEQ_in_assignmentOperator5122); if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:955:9: '*=' |
| { |
| dbg.location(955,9); |
| match(input,STAREQ,FOLLOW_STAREQ_in_assignmentOperator5132); if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:956:9: '/=' |
| { |
| dbg.location(956,9); |
| match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignmentOperator5142); if (state.failed) return ; |
| |
| } |
| break; |
| case 6 : |
| dbg.enterAlt(6); |
| |
| // src/com/google/doclava/parser/Java.g:957:9: '&=' |
| { |
| dbg.location(957,9); |
| match(input,AMPEQ,FOLLOW_AMPEQ_in_assignmentOperator5152); if (state.failed) return ; |
| |
| } |
| break; |
| case 7 : |
| dbg.enterAlt(7); |
| |
| // src/com/google/doclava/parser/Java.g:958:9: '|=' |
| { |
| dbg.location(958,9); |
| match(input,BAREQ,FOLLOW_BAREQ_in_assignmentOperator5162); if (state.failed) return ; |
| |
| } |
| break; |
| case 8 : |
| dbg.enterAlt(8); |
| |
| // src/com/google/doclava/parser/Java.g:959:9: '^=' |
| { |
| dbg.location(959,9); |
| match(input,CARETEQ,FOLLOW_CARETEQ_in_assignmentOperator5172); if (state.failed) return ; |
| |
| } |
| break; |
| case 9 : |
| dbg.enterAlt(9); |
| |
| // src/com/google/doclava/parser/Java.g:960:9: '%=' |
| { |
| dbg.location(960,9); |
| match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignmentOperator5182); if (state.failed) return ; |
| |
| } |
| break; |
| case 10 : |
| dbg.enterAlt(10); |
| |
| // src/com/google/doclava/parser/Java.g:961:10: '<' '<' '=' |
| { |
| dbg.location(961,10); |
| match(input,LT,FOLLOW_LT_in_assignmentOperator5193); if (state.failed) return ; |
| dbg.location(961,14); |
| match(input,LT,FOLLOW_LT_in_assignmentOperator5195); if (state.failed) return ; |
| dbg.location(961,18); |
| match(input,EQ,FOLLOW_EQ_in_assignmentOperator5197); if (state.failed) return ; |
| |
| } |
| break; |
| case 11 : |
| dbg.enterAlt(11); |
| |
| // src/com/google/doclava/parser/Java.g:962:10: '>' '>' '>' '=' |
| { |
| dbg.location(962,10); |
| match(input,GT,FOLLOW_GT_in_assignmentOperator5208); if (state.failed) return ; |
| dbg.location(962,14); |
| match(input,GT,FOLLOW_GT_in_assignmentOperator5210); if (state.failed) return ; |
| dbg.location(962,18); |
| match(input,GT,FOLLOW_GT_in_assignmentOperator5212); if (state.failed) return ; |
| dbg.location(962,22); |
| match(input,EQ,FOLLOW_EQ_in_assignmentOperator5214); if (state.failed) return ; |
| |
| } |
| break; |
| case 12 : |
| dbg.enterAlt(12); |
| |
| // src/com/google/doclava/parser/Java.g:963:10: '>' '>' '=' |
| { |
| dbg.location(963,10); |
| match(input,GT,FOLLOW_GT_in_assignmentOperator5225); if (state.failed) return ; |
| dbg.location(963,14); |
| match(input,GT,FOLLOW_GT_in_assignmentOperator5227); if (state.failed) return ; |
| dbg.location(963,18); |
| match(input,EQ,FOLLOW_EQ_in_assignmentOperator5229); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 71, assignmentOperator_StartIndex); } |
| } |
| dbg.location(964, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "assignmentOperator"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "assignmentOperator" |
| |
| |
| // $ANTLR start "conditionalExpression" |
| // src/com/google/doclava/parser/Java.g:967:1: conditionalExpression : conditionalOrExpression ( '?' expression ':' conditionalExpression )? ; |
| public final void conditionalExpression() throws RecognitionException { |
| int conditionalExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "conditionalExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(967, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:968:5: ( conditionalOrExpression ( '?' expression ':' conditionalExpression )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:968:9: conditionalOrExpression ( '?' expression ':' conditionalExpression )? |
| { |
| dbg.location(968,9); |
| pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression5249); |
| conditionalOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(969,9); |
| // src/com/google/doclava/parser/Java.g:969:9: ( '?' expression ':' conditionalExpression )? |
| int alt113=2; |
| try { dbg.enterSubRule(113); |
| try { dbg.enterDecision(113, decisionCanBacktrack[113]); |
| |
| int LA113_0 = input.LA(1); |
| |
| if ( (LA113_0==QUES) ) { |
| alt113=1; |
| } |
| } finally {dbg.exitDecision(113);} |
| |
| switch (alt113) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:969:10: '?' expression ':' conditionalExpression |
| { |
| dbg.location(969,10); |
| match(input,QUES,FOLLOW_QUES_in_conditionalExpression5260); if (state.failed) return ; |
| dbg.location(969,14); |
| pushFollow(FOLLOW_expression_in_conditionalExpression5262); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(969,25); |
| match(input,COLON,FOLLOW_COLON_in_conditionalExpression5264); if (state.failed) return ; |
| dbg.location(969,29); |
| pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression5266); |
| conditionalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(113);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 72, conditionalExpression_StartIndex); } |
| } |
| dbg.location(971, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "conditionalExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "conditionalExpression" |
| |
| |
| // $ANTLR start "conditionalOrExpression" |
| // src/com/google/doclava/parser/Java.g:973:1: conditionalOrExpression : conditionalAndExpression ( '||' conditionalAndExpression )* ; |
| public final void conditionalOrExpression() throws RecognitionException { |
| int conditionalOrExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "conditionalOrExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(973, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:974:5: ( conditionalAndExpression ( '||' conditionalAndExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:974:9: conditionalAndExpression ( '||' conditionalAndExpression )* |
| { |
| dbg.location(974,9); |
| pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296); |
| conditionalAndExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(975,9); |
| // src/com/google/doclava/parser/Java.g:975:9: ( '||' conditionalAndExpression )* |
| try { dbg.enterSubRule(114); |
| |
| loop114: |
| do { |
| int alt114=2; |
| try { dbg.enterDecision(114, decisionCanBacktrack[114]); |
| |
| int LA114_0 = input.LA(1); |
| |
| if ( (LA114_0==BARBAR) ) { |
| alt114=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(114);} |
| |
| switch (alt114) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:975:10: '||' conditionalAndExpression |
| { |
| dbg.location(975,10); |
| match(input,BARBAR,FOLLOW_BARBAR_in_conditionalOrExpression5307); if (state.failed) return ; |
| dbg.location(975,15); |
| pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309); |
| conditionalAndExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop114; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(114);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 73, conditionalOrExpression_StartIndex); } |
| } |
| dbg.location(977, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "conditionalOrExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "conditionalOrExpression" |
| |
| |
| // $ANTLR start "conditionalAndExpression" |
| // src/com/google/doclava/parser/Java.g:979:1: conditionalAndExpression : inclusiveOrExpression ( '&&' inclusiveOrExpression )* ; |
| public final void conditionalAndExpression() throws RecognitionException { |
| int conditionalAndExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "conditionalAndExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(979, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:980:5: ( inclusiveOrExpression ( '&&' inclusiveOrExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:980:9: inclusiveOrExpression ( '&&' inclusiveOrExpression )* |
| { |
| dbg.location(980,9); |
| pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339); |
| inclusiveOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(981,9); |
| // src/com/google/doclava/parser/Java.g:981:9: ( '&&' inclusiveOrExpression )* |
| try { dbg.enterSubRule(115); |
| |
| loop115: |
| do { |
| int alt115=2; |
| try { dbg.enterDecision(115, decisionCanBacktrack[115]); |
| |
| int LA115_0 = input.LA(1); |
| |
| if ( (LA115_0==AMPAMP) ) { |
| alt115=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(115);} |
| |
| switch (alt115) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:981:10: '&&' inclusiveOrExpression |
| { |
| dbg.location(981,10); |
| match(input,AMPAMP,FOLLOW_AMPAMP_in_conditionalAndExpression5350); if (state.failed) return ; |
| dbg.location(981,15); |
| pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352); |
| inclusiveOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop115; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(115);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 74, conditionalAndExpression_StartIndex); } |
| } |
| dbg.location(983, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "conditionalAndExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "conditionalAndExpression" |
| |
| |
| // $ANTLR start "inclusiveOrExpression" |
| // src/com/google/doclava/parser/Java.g:985:1: inclusiveOrExpression : exclusiveOrExpression ( '|' exclusiveOrExpression )* ; |
| public final void inclusiveOrExpression() throws RecognitionException { |
| int inclusiveOrExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "inclusiveOrExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(985, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:986:5: ( exclusiveOrExpression ( '|' exclusiveOrExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:986:9: exclusiveOrExpression ( '|' exclusiveOrExpression )* |
| { |
| dbg.location(986,9); |
| pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382); |
| exclusiveOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(987,9); |
| // src/com/google/doclava/parser/Java.g:987:9: ( '|' exclusiveOrExpression )* |
| try { dbg.enterSubRule(116); |
| |
| loop116: |
| do { |
| int alt116=2; |
| try { dbg.enterDecision(116, decisionCanBacktrack[116]); |
| |
| int LA116_0 = input.LA(1); |
| |
| if ( (LA116_0==BAR) ) { |
| alt116=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(116);} |
| |
| switch (alt116) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:987:10: '|' exclusiveOrExpression |
| { |
| dbg.location(987,10); |
| match(input,BAR,FOLLOW_BAR_in_inclusiveOrExpression5393); if (state.failed) return ; |
| dbg.location(987,14); |
| pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395); |
| exclusiveOrExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop116; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(116);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 75, inclusiveOrExpression_StartIndex); } |
| } |
| dbg.location(989, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "inclusiveOrExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "inclusiveOrExpression" |
| |
| |
| // $ANTLR start "exclusiveOrExpression" |
| // src/com/google/doclava/parser/Java.g:991:1: exclusiveOrExpression : andExpression ( '^' andExpression )* ; |
| public final void exclusiveOrExpression() throws RecognitionException { |
| int exclusiveOrExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "exclusiveOrExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(991, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:992:5: ( andExpression ( '^' andExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:992:9: andExpression ( '^' andExpression )* |
| { |
| dbg.location(992,9); |
| pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5425); |
| andExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(993,9); |
| // src/com/google/doclava/parser/Java.g:993:9: ( '^' andExpression )* |
| try { dbg.enterSubRule(117); |
| |
| loop117: |
| do { |
| int alt117=2; |
| try { dbg.enterDecision(117, decisionCanBacktrack[117]); |
| |
| int LA117_0 = input.LA(1); |
| |
| if ( (LA117_0==CARET) ) { |
| alt117=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(117);} |
| |
| switch (alt117) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:993:10: '^' andExpression |
| { |
| dbg.location(993,10); |
| match(input,CARET,FOLLOW_CARET_in_exclusiveOrExpression5436); if (state.failed) return ; |
| dbg.location(993,14); |
| pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5438); |
| andExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop117; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(117);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 76, exclusiveOrExpression_StartIndex); } |
| } |
| dbg.location(995, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "exclusiveOrExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "exclusiveOrExpression" |
| |
| |
| // $ANTLR start "andExpression" |
| // src/com/google/doclava/parser/Java.g:997:1: andExpression : equalityExpression ( '&' equalityExpression )* ; |
| public final void andExpression() throws RecognitionException { |
| int andExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "andExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(997, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:998:5: ( equalityExpression ( '&' equalityExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:998:9: equalityExpression ( '&' equalityExpression )* |
| { |
| dbg.location(998,9); |
| pushFollow(FOLLOW_equalityExpression_in_andExpression5468); |
| equalityExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(999,9); |
| // src/com/google/doclava/parser/Java.g:999:9: ( '&' equalityExpression )* |
| try { dbg.enterSubRule(118); |
| |
| loop118: |
| do { |
| int alt118=2; |
| try { dbg.enterDecision(118, decisionCanBacktrack[118]); |
| |
| int LA118_0 = input.LA(1); |
| |
| if ( (LA118_0==AMP) ) { |
| alt118=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(118);} |
| |
| switch (alt118) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:999:10: '&' equalityExpression |
| { |
| dbg.location(999,10); |
| match(input,AMP,FOLLOW_AMP_in_andExpression5479); if (state.failed) return ; |
| dbg.location(999,14); |
| pushFollow(FOLLOW_equalityExpression_in_andExpression5481); |
| equalityExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop118; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(118);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 77, andExpression_StartIndex); } |
| } |
| dbg.location(1001, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "andExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "andExpression" |
| |
| |
| // $ANTLR start "equalityExpression" |
| // src/com/google/doclava/parser/Java.g:1003:1: equalityExpression : instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ; |
| public final void equalityExpression() throws RecognitionException { |
| int equalityExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "equalityExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1003, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1004:5: ( instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1004:9: instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* |
| { |
| dbg.location(1004,9); |
| pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5511); |
| instanceOfExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1005,9); |
| // src/com/google/doclava/parser/Java.g:1005:9: ( ( '==' | '!=' ) instanceOfExpression )* |
| try { dbg.enterSubRule(119); |
| |
| loop119: |
| do { |
| int alt119=2; |
| try { dbg.enterDecision(119, decisionCanBacktrack[119]); |
| |
| int LA119_0 = input.LA(1); |
| |
| if ( (LA119_0==EQEQ||LA119_0==BANGEQ) ) { |
| alt119=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(119);} |
| |
| switch (alt119) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1006:13: ( '==' | '!=' ) instanceOfExpression |
| { |
| dbg.location(1006,13); |
| if ( input.LA(1)==EQEQ||input.LA(1)==BANGEQ ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(1009,13); |
| pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5585); |
| instanceOfExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop119; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(119);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 78, equalityExpression_StartIndex); } |
| } |
| dbg.location(1011, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "equalityExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "equalityExpression" |
| |
| |
| // $ANTLR start "instanceOfExpression" |
| // src/com/google/doclava/parser/Java.g:1013:1: instanceOfExpression : relationalExpression ( 'instanceof' type )? ; |
| public final void instanceOfExpression() throws RecognitionException { |
| int instanceOfExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "instanceOfExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1013, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1014:5: ( relationalExpression ( 'instanceof' type )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1014:9: relationalExpression ( 'instanceof' type )? |
| { |
| dbg.location(1014,9); |
| pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression5615); |
| relationalExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1015,9); |
| // src/com/google/doclava/parser/Java.g:1015:9: ( 'instanceof' type )? |
| int alt120=2; |
| try { dbg.enterSubRule(120); |
| try { dbg.enterDecision(120, decisionCanBacktrack[120]); |
| |
| int LA120_0 = input.LA(1); |
| |
| if ( (LA120_0==INSTANCEOF) ) { |
| alt120=1; |
| } |
| } finally {dbg.exitDecision(120);} |
| |
| switch (alt120) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1015:10: 'instanceof' type |
| { |
| dbg.location(1015,10); |
| match(input,INSTANCEOF,FOLLOW_INSTANCEOF_in_instanceOfExpression5626); if (state.failed) return ; |
| dbg.location(1015,23); |
| pushFollow(FOLLOW_type_in_instanceOfExpression5628); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(120);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 79, instanceOfExpression_StartIndex); } |
| } |
| dbg.location(1017, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "instanceOfExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "instanceOfExpression" |
| |
| |
| // $ANTLR start "relationalExpression" |
| // src/com/google/doclava/parser/Java.g:1019:1: relationalExpression : shiftExpression ( relationalOp shiftExpression )* ; |
| public final void relationalExpression() throws RecognitionException { |
| int relationalExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "relationalExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1019, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1020:5: ( shiftExpression ( relationalOp shiftExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1020:9: shiftExpression ( relationalOp shiftExpression )* |
| { |
| dbg.location(1020,9); |
| pushFollow(FOLLOW_shiftExpression_in_relationalExpression5658); |
| shiftExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1021,9); |
| // src/com/google/doclava/parser/Java.g:1021:9: ( relationalOp shiftExpression )* |
| try { dbg.enterSubRule(121); |
| |
| loop121: |
| do { |
| int alt121=2; |
| try { dbg.enterDecision(121, decisionCanBacktrack[121]); |
| |
| int LA121_0 = input.LA(1); |
| |
| if ( (LA121_0==LT) ) { |
| int LA121_2 = input.LA(2); |
| |
| if ( ((LA121_2>=IDENTIFIER && LA121_2<=NULL)||LA121_2==BOOLEAN||LA121_2==BYTE||LA121_2==CHAR||LA121_2==DOUBLE||LA121_2==FLOAT||LA121_2==INT||LA121_2==LONG||LA121_2==NEW||LA121_2==SHORT||LA121_2==SUPER||LA121_2==THIS||LA121_2==VOID||LA121_2==LPAREN||(LA121_2>=EQ && LA121_2<=TILDE)||(LA121_2>=PLUSPLUS && LA121_2<=SUB)) ) { |
| alt121=1; |
| } |
| |
| |
| } |
| else if ( (LA121_0==GT) ) { |
| int LA121_3 = input.LA(2); |
| |
| if ( ((LA121_3>=IDENTIFIER && LA121_3<=NULL)||LA121_3==BOOLEAN||LA121_3==BYTE||LA121_3==CHAR||LA121_3==DOUBLE||LA121_3==FLOAT||LA121_3==INT||LA121_3==LONG||LA121_3==NEW||LA121_3==SHORT||LA121_3==SUPER||LA121_3==THIS||LA121_3==VOID||LA121_3==LPAREN||(LA121_3>=EQ && LA121_3<=TILDE)||(LA121_3>=PLUSPLUS && LA121_3<=SUB)) ) { |
| alt121=1; |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(121);} |
| |
| switch (alt121) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1021:10: relationalOp shiftExpression |
| { |
| dbg.location(1021,10); |
| pushFollow(FOLLOW_relationalOp_in_relationalExpression5669); |
| relationalOp(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1021,23); |
| pushFollow(FOLLOW_shiftExpression_in_relationalExpression5671); |
| shiftExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop121; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(121);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 80, relationalExpression_StartIndex); } |
| } |
| dbg.location(1023, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "relationalExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "relationalExpression" |
| |
| |
| // $ANTLR start "relationalOp" |
| // src/com/google/doclava/parser/Java.g:1025:1: relationalOp : ( '<' '=' | '>' '=' | '<' | '>' ); |
| public final void relationalOp() throws RecognitionException { |
| int relationalOp_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "relationalOp"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1025, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1026:5: ( '<' '=' | '>' '=' | '<' | '>' ) |
| int alt122=4; |
| try { dbg.enterDecision(122, decisionCanBacktrack[122]); |
| |
| int LA122_0 = input.LA(1); |
| |
| if ( (LA122_0==LT) ) { |
| int LA122_1 = input.LA(2); |
| |
| if ( (LA122_1==EQ) ) { |
| alt122=1; |
| } |
| else if ( ((LA122_1>=IDENTIFIER && LA122_1<=NULL)||LA122_1==BOOLEAN||LA122_1==BYTE||LA122_1==CHAR||LA122_1==DOUBLE||LA122_1==FLOAT||LA122_1==INT||LA122_1==LONG||LA122_1==NEW||LA122_1==SHORT||LA122_1==SUPER||LA122_1==THIS||LA122_1==VOID||LA122_1==LPAREN||(LA122_1>=BANG && LA122_1<=TILDE)||(LA122_1>=PLUSPLUS && LA122_1<=SUB)) ) { |
| alt122=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 122, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else if ( (LA122_0==GT) ) { |
| int LA122_2 = input.LA(2); |
| |
| if ( (LA122_2==EQ) ) { |
| alt122=2; |
| } |
| else if ( ((LA122_2>=IDENTIFIER && LA122_2<=NULL)||LA122_2==BOOLEAN||LA122_2==BYTE||LA122_2==CHAR||LA122_2==DOUBLE||LA122_2==FLOAT||LA122_2==INT||LA122_2==LONG||LA122_2==NEW||LA122_2==SHORT||LA122_2==SUPER||LA122_2==THIS||LA122_2==VOID||LA122_2==LPAREN||(LA122_2>=BANG && LA122_2<=TILDE)||(LA122_2>=PLUSPLUS && LA122_2<=SUB)) ) { |
| alt122=4; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 122, 2, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 122, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(122);} |
| |
| switch (alt122) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1026:10: '<' '=' |
| { |
| dbg.location(1026,10); |
| match(input,LT,FOLLOW_LT_in_relationalOp5702); if (state.failed) return ; |
| dbg.location(1026,14); |
| match(input,EQ,FOLLOW_EQ_in_relationalOp5704); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1027:10: '>' '=' |
| { |
| dbg.location(1027,10); |
| match(input,GT,FOLLOW_GT_in_relationalOp5715); if (state.failed) return ; |
| dbg.location(1027,14); |
| match(input,EQ,FOLLOW_EQ_in_relationalOp5717); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1028:9: '<' |
| { |
| dbg.location(1028,9); |
| match(input,LT,FOLLOW_LT_in_relationalOp5727); if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:1029:9: '>' |
| { |
| dbg.location(1029,9); |
| match(input,GT,FOLLOW_GT_in_relationalOp5737); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 81, relationalOp_StartIndex); } |
| } |
| dbg.location(1030, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "relationalOp"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "relationalOp" |
| |
| |
| // $ANTLR start "shiftExpression" |
| // src/com/google/doclava/parser/Java.g:1032:1: shiftExpression : additiveExpression ( shiftOp additiveExpression )* ; |
| public final void shiftExpression() throws RecognitionException { |
| int shiftExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "shiftExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1032, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1033:5: ( additiveExpression ( shiftOp additiveExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1033:9: additiveExpression ( shiftOp additiveExpression )* |
| { |
| dbg.location(1033,9); |
| pushFollow(FOLLOW_additiveExpression_in_shiftExpression5756); |
| additiveExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1034,9); |
| // src/com/google/doclava/parser/Java.g:1034:9: ( shiftOp additiveExpression )* |
| try { dbg.enterSubRule(123); |
| |
| loop123: |
| do { |
| int alt123=2; |
| try { dbg.enterDecision(123, decisionCanBacktrack[123]); |
| |
| int LA123_0 = input.LA(1); |
| |
| if ( (LA123_0==LT) ) { |
| int LA123_1 = input.LA(2); |
| |
| if ( (LA123_1==LT) ) { |
| int LA123_4 = input.LA(3); |
| |
| if ( ((LA123_4>=IDENTIFIER && LA123_4<=NULL)||LA123_4==BOOLEAN||LA123_4==BYTE||LA123_4==CHAR||LA123_4==DOUBLE||LA123_4==FLOAT||LA123_4==INT||LA123_4==LONG||LA123_4==NEW||LA123_4==SHORT||LA123_4==SUPER||LA123_4==THIS||LA123_4==VOID||LA123_4==LPAREN||(LA123_4>=BANG && LA123_4<=TILDE)||(LA123_4>=PLUSPLUS && LA123_4<=SUB)) ) { |
| alt123=1; |
| } |
| |
| |
| } |
| |
| |
| } |
| else if ( (LA123_0==GT) ) { |
| int LA123_2 = input.LA(2); |
| |
| if ( (LA123_2==GT) ) { |
| int LA123_5 = input.LA(3); |
| |
| if ( (LA123_5==GT) ) { |
| int LA123_7 = input.LA(4); |
| |
| if ( ((LA123_7>=IDENTIFIER && LA123_7<=NULL)||LA123_7==BOOLEAN||LA123_7==BYTE||LA123_7==CHAR||LA123_7==DOUBLE||LA123_7==FLOAT||LA123_7==INT||LA123_7==LONG||LA123_7==NEW||LA123_7==SHORT||LA123_7==SUPER||LA123_7==THIS||LA123_7==VOID||LA123_7==LPAREN||(LA123_7>=BANG && LA123_7<=TILDE)||(LA123_7>=PLUSPLUS && LA123_7<=SUB)) ) { |
| alt123=1; |
| } |
| |
| |
| } |
| else if ( ((LA123_5>=IDENTIFIER && LA123_5<=NULL)||LA123_5==BOOLEAN||LA123_5==BYTE||LA123_5==CHAR||LA123_5==DOUBLE||LA123_5==FLOAT||LA123_5==INT||LA123_5==LONG||LA123_5==NEW||LA123_5==SHORT||LA123_5==SUPER||LA123_5==THIS||LA123_5==VOID||LA123_5==LPAREN||(LA123_5>=BANG && LA123_5<=TILDE)||(LA123_5>=PLUSPLUS && LA123_5<=SUB)) ) { |
| alt123=1; |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(123);} |
| |
| switch (alt123) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1034:10: shiftOp additiveExpression |
| { |
| dbg.location(1034,10); |
| pushFollow(FOLLOW_shiftOp_in_shiftExpression5767); |
| shiftOp(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1034,18); |
| pushFollow(FOLLOW_additiveExpression_in_shiftExpression5769); |
| additiveExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop123; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(123);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 82, shiftExpression_StartIndex); } |
| } |
| dbg.location(1036, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "shiftExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "shiftExpression" |
| |
| |
| // $ANTLR start "shiftOp" |
| // src/com/google/doclava/parser/Java.g:1039:1: shiftOp : ( '<' '<' | '>' '>' '>' | '>' '>' ); |
| public final void shiftOp() throws RecognitionException { |
| int shiftOp_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "shiftOp"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1039, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1040:5: ( '<' '<' | '>' '>' '>' | '>' '>' ) |
| int alt124=3; |
| try { dbg.enterDecision(124, decisionCanBacktrack[124]); |
| |
| int LA124_0 = input.LA(1); |
| |
| if ( (LA124_0==LT) ) { |
| alt124=1; |
| } |
| else if ( (LA124_0==GT) ) { |
| int LA124_2 = input.LA(2); |
| |
| if ( (LA124_2==GT) ) { |
| int LA124_3 = input.LA(3); |
| |
| if ( (LA124_3==GT) ) { |
| alt124=2; |
| } |
| else if ( ((LA124_3>=IDENTIFIER && LA124_3<=NULL)||LA124_3==BOOLEAN||LA124_3==BYTE||LA124_3==CHAR||LA124_3==DOUBLE||LA124_3==FLOAT||LA124_3==INT||LA124_3==LONG||LA124_3==NEW||LA124_3==SHORT||LA124_3==SUPER||LA124_3==THIS||LA124_3==VOID||LA124_3==LPAREN||(LA124_3>=BANG && LA124_3<=TILDE)||(LA124_3>=PLUSPLUS && LA124_3<=SUB)) ) { |
| alt124=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 124, 3, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 124, 2, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 124, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(124);} |
| |
| switch (alt124) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1040:10: '<' '<' |
| { |
| dbg.location(1040,10); |
| match(input,LT,FOLLOW_LT_in_shiftOp5801); if (state.failed) return ; |
| dbg.location(1040,14); |
| match(input,LT,FOLLOW_LT_in_shiftOp5803); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1041:10: '>' '>' '>' |
| { |
| dbg.location(1041,10); |
| match(input,GT,FOLLOW_GT_in_shiftOp5814); if (state.failed) return ; |
| dbg.location(1041,14); |
| match(input,GT,FOLLOW_GT_in_shiftOp5816); if (state.failed) return ; |
| dbg.location(1041,18); |
| match(input,GT,FOLLOW_GT_in_shiftOp5818); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1042:10: '>' '>' |
| { |
| dbg.location(1042,10); |
| match(input,GT,FOLLOW_GT_in_shiftOp5829); if (state.failed) return ; |
| dbg.location(1042,14); |
| match(input,GT,FOLLOW_GT_in_shiftOp5831); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 83, shiftOp_StartIndex); } |
| } |
| dbg.location(1043, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "shiftOp"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "shiftOp" |
| |
| |
| // $ANTLR start "additiveExpression" |
| // src/com/google/doclava/parser/Java.g:1046:1: additiveExpression : multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ; |
| public final void additiveExpression() throws RecognitionException { |
| int additiveExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "additiveExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1046, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1047:5: ( multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1047:9: multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* |
| { |
| dbg.location(1047,9); |
| pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5851); |
| multiplicativeExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1048,9); |
| // src/com/google/doclava/parser/Java.g:1048:9: ( ( '+' | '-' ) multiplicativeExpression )* |
| try { dbg.enterSubRule(125); |
| |
| loop125: |
| do { |
| int alt125=2; |
| try { dbg.enterDecision(125, decisionCanBacktrack[125]); |
| |
| int LA125_0 = input.LA(1); |
| |
| if ( ((LA125_0>=PLUS && LA125_0<=SUB)) ) { |
| alt125=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(125);} |
| |
| switch (alt125) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1049:13: ( '+' | '-' ) multiplicativeExpression |
| { |
| dbg.location(1049,13); |
| if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(1052,13); |
| pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5925); |
| multiplicativeExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop125; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(125);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 84, additiveExpression_StartIndex); } |
| } |
| dbg.location(1054, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "additiveExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "additiveExpression" |
| |
| |
| // $ANTLR start "multiplicativeExpression" |
| // src/com/google/doclava/parser/Java.g:1056:1: multiplicativeExpression : unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ; |
| public final void multiplicativeExpression() throws RecognitionException { |
| int multiplicativeExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "multiplicativeExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1056, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1057:5: ( unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1058:9: unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* |
| { |
| dbg.location(1058,9); |
| pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5962); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1059,9); |
| // src/com/google/doclava/parser/Java.g:1059:9: ( ( '*' | '/' | '%' ) unaryExpression )* |
| try { dbg.enterSubRule(126); |
| |
| loop126: |
| do { |
| int alt126=2; |
| try { dbg.enterDecision(126, decisionCanBacktrack[126]); |
| |
| int LA126_0 = input.LA(1); |
| |
| if ( ((LA126_0>=STAR && LA126_0<=SLASH)||LA126_0==PERCENT) ) { |
| alt126=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(126);} |
| |
| switch (alt126) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1060:13: ( '*' | '/' | '%' ) unaryExpression |
| { |
| dbg.location(1060,13); |
| if ( (input.LA(1)>=STAR && input.LA(1)<=SLASH)||input.LA(1)==PERCENT ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(1064,13); |
| pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression6054); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop126; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(126);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 85, multiplicativeExpression_StartIndex); } |
| } |
| dbg.location(1066, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "multiplicativeExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "multiplicativeExpression" |
| |
| |
| // $ANTLR start "unaryExpression" |
| // src/com/google/doclava/parser/Java.g:1068:1: unaryExpression : ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus ); |
| public final void unaryExpression() throws RecognitionException { |
| int unaryExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "unaryExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1068, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1073:5: ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus ) |
| int alt127=5; |
| try { dbg.enterDecision(127, decisionCanBacktrack[127]); |
| |
| switch ( input.LA(1) ) { |
| case PLUS: |
| { |
| alt127=1; |
| } |
| break; |
| case SUB: |
| { |
| alt127=2; |
| } |
| break; |
| case PLUSPLUS: |
| { |
| alt127=3; |
| } |
| break; |
| case SUBSUB: |
| { |
| alt127=4; |
| } |
| break; |
| case IDENTIFIER: |
| case INTLITERAL: |
| case LONGLITERAL: |
| case FLOATLITERAL: |
| case DOUBLELITERAL: |
| case CHARLITERAL: |
| case STRINGLITERAL: |
| case TRUE: |
| case FALSE: |
| case NULL: |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case NEW: |
| case SHORT: |
| case SUPER: |
| case THIS: |
| case VOID: |
| case LPAREN: |
| case BANG: |
| case TILDE: |
| { |
| alt127=5; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 127, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } finally {dbg.exitDecision(127);} |
| |
| switch (alt127) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1073:9: '+' unaryExpression |
| { |
| dbg.location(1073,9); |
| match(input,PLUS,FOLLOW_PLUS_in_unaryExpression6086); if (state.failed) return ; |
| dbg.location(1073,14); |
| pushFollow(FOLLOW_unaryExpression_in_unaryExpression6089); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1074:9: '-' unaryExpression |
| { |
| dbg.location(1074,9); |
| match(input,SUB,FOLLOW_SUB_in_unaryExpression6099); if (state.failed) return ; |
| dbg.location(1074,13); |
| pushFollow(FOLLOW_unaryExpression_in_unaryExpression6101); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1075:9: '++' unaryExpression |
| { |
| dbg.location(1075,9); |
| match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpression6111); if (state.failed) return ; |
| dbg.location(1075,14); |
| pushFollow(FOLLOW_unaryExpression_in_unaryExpression6113); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:1076:9: '--' unaryExpression |
| { |
| dbg.location(1076,9); |
| match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpression6123); if (state.failed) return ; |
| dbg.location(1076,14); |
| pushFollow(FOLLOW_unaryExpression_in_unaryExpression6125); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:1077:9: unaryExpressionNotPlusMinus |
| { |
| dbg.location(1077,9); |
| pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135); |
| unaryExpressionNotPlusMinus(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 86, unaryExpression_StartIndex); } |
| } |
| dbg.location(1078, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "unaryExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "unaryExpression" |
| |
| |
| // $ANTLR start "unaryExpressionNotPlusMinus" |
| // src/com/google/doclava/parser/Java.g:1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? ); |
| public final void unaryExpressionNotPlusMinus() throws RecognitionException { |
| int unaryExpressionNotPlusMinus_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "unaryExpressionNotPlusMinus"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1080, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1081:5: ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? ) |
| int alt130=4; |
| try { dbg.enterDecision(130, decisionCanBacktrack[130]); |
| |
| try { |
| isCyclicDecision = true; |
| alt130 = dfa130.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(130);} |
| |
| switch (alt130) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1081:9: '~' unaryExpression |
| { |
| dbg.location(1081,9); |
| match(input,TILDE,FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154); if (state.failed) return ; |
| dbg.location(1081,13); |
| pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1082:9: '!' unaryExpression |
| { |
| dbg.location(1082,9); |
| match(input,BANG,FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166); if (state.failed) return ; |
| dbg.location(1082,13); |
| pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1083:9: castExpression |
| { |
| dbg.location(1083,9); |
| pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178); |
| castExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:1084:9: primary ( selector )* ( '++' | '--' )? |
| { |
| dbg.location(1084,9); |
| pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus6188); |
| primary(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1085,9); |
| // src/com/google/doclava/parser/Java.g:1085:9: ( selector )* |
| try { dbg.enterSubRule(128); |
| |
| loop128: |
| do { |
| int alt128=2; |
| try { dbg.enterDecision(128, decisionCanBacktrack[128]); |
| |
| int LA128_0 = input.LA(1); |
| |
| if ( (LA128_0==LBRACKET||LA128_0==DOT) ) { |
| alt128=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(128);} |
| |
| switch (alt128) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1085:10: selector |
| { |
| dbg.location(1085,10); |
| pushFollow(FOLLOW_selector_in_unaryExpressionNotPlusMinus6199); |
| selector(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop128; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(128);} |
| |
| dbg.location(1087,9); |
| // src/com/google/doclava/parser/Java.g:1087:9: ( '++' | '--' )? |
| int alt129=2; |
| try { dbg.enterSubRule(129); |
| try { dbg.enterDecision(129, decisionCanBacktrack[129]); |
| |
| int LA129_0 = input.LA(1); |
| |
| if ( ((LA129_0>=PLUSPLUS && LA129_0<=SUBSUB)) ) { |
| alt129=1; |
| } |
| } finally {dbg.exitDecision(129);} |
| |
| switch (alt129) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g: |
| { |
| dbg.location(1087,9); |
| if ( (input.LA(1)>=PLUSPLUS && input.LA(1)<=SUBSUB) ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(129);} |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 87, unaryExpressionNotPlusMinus_StartIndex); } |
| } |
| dbg.location(1090, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "unaryExpressionNotPlusMinus"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "unaryExpressionNotPlusMinus" |
| |
| |
| // $ANTLR start "castExpression" |
| // src/com/google/doclava/parser/Java.g:1092:1: castExpression : ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus ); |
| public final void castExpression() throws RecognitionException { |
| int castExpression_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "castExpression"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1092, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1093:5: ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus ) |
| int alt131=2; |
| try { dbg.enterDecision(131, decisionCanBacktrack[131]); |
| |
| int LA131_0 = input.LA(1); |
| |
| if ( (LA131_0==LPAREN) ) { |
| int LA131_1 = input.LA(2); |
| |
| if ( (synpred206_Java()) ) { |
| alt131=1; |
| } |
| else if ( (true) ) { |
| alt131=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 131, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 131, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(131);} |
| |
| switch (alt131) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression |
| { |
| dbg.location(1093,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6268); if (state.failed) return ; |
| dbg.location(1093,13); |
| pushFollow(FOLLOW_primitiveType_in_castExpression6270); |
| primitiveType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1093,27); |
| match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6272); if (state.failed) return ; |
| dbg.location(1093,31); |
| pushFollow(FOLLOW_unaryExpression_in_castExpression6274); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1094:9: '(' type ')' unaryExpressionNotPlusMinus |
| { |
| dbg.location(1094,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6284); if (state.failed) return ; |
| dbg.location(1094,13); |
| pushFollow(FOLLOW_type_in_castExpression6286); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1094,18); |
| match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6288); if (state.failed) return ; |
| dbg.location(1094,22); |
| pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290); |
| unaryExpressionNotPlusMinus(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 88, castExpression_StartIndex); } |
| } |
| dbg.location(1095, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "castExpression"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "castExpression" |
| |
| |
| // $ANTLR start "primary" |
| // src/com/google/doclava/parser/Java.g:1097:1: primary : ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' ); |
| public final void primary() throws RecognitionException { |
| int primary_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "primary"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1097, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1101:5: ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' ) |
| int alt137=8; |
| try { dbg.enterDecision(137, decisionCanBacktrack[137]); |
| |
| switch ( input.LA(1) ) { |
| case LPAREN: |
| { |
| alt137=1; |
| } |
| break; |
| case THIS: |
| { |
| alt137=2; |
| } |
| break; |
| case IDENTIFIER: |
| { |
| alt137=3; |
| } |
| break; |
| case SUPER: |
| { |
| alt137=4; |
| } |
| break; |
| case INTLITERAL: |
| case LONGLITERAL: |
| case FLOATLITERAL: |
| case DOUBLELITERAL: |
| case CHARLITERAL: |
| case STRINGLITERAL: |
| case TRUE: |
| case FALSE: |
| case NULL: |
| { |
| alt137=5; |
| } |
| break; |
| case NEW: |
| { |
| alt137=6; |
| } |
| break; |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| { |
| alt137=7; |
| } |
| break; |
| case VOID: |
| { |
| alt137=8; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 137, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } finally {dbg.exitDecision(137);} |
| |
| switch (alt137) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1101:9: parExpression |
| { |
| dbg.location(1101,9); |
| pushFollow(FOLLOW_parExpression_in_primary6311); |
| parExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1102:9: 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? |
| { |
| dbg.location(1102,9); |
| match(input,THIS,FOLLOW_THIS_in_primary6321); if (state.failed) return ; |
| dbg.location(1103,9); |
| // src/com/google/doclava/parser/Java.g:1103:9: ( '.' IDENTIFIER )* |
| try { dbg.enterSubRule(132); |
| |
| loop132: |
| do { |
| int alt132=2; |
| try { dbg.enterDecision(132, decisionCanBacktrack[132]); |
| |
| int LA132_0 = input.LA(1); |
| |
| if ( (LA132_0==DOT) ) { |
| int LA132_2 = input.LA(2); |
| |
| if ( (LA132_2==IDENTIFIER) ) { |
| int LA132_3 = input.LA(3); |
| |
| if ( (synpred208_Java()) ) { |
| alt132=1; |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(132);} |
| |
| switch (alt132) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER |
| { |
| dbg.location(1103,10); |
| match(input,DOT,FOLLOW_DOT_in_primary6332); if (state.failed) return ; |
| dbg.location(1103,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6334); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop132; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(132);} |
| |
| dbg.location(1105,9); |
| // src/com/google/doclava/parser/Java.g:1105:9: ( identifierSuffix )? |
| int alt133=2; |
| try { dbg.enterSubRule(133); |
| try { dbg.enterDecision(133, decisionCanBacktrack[133]); |
| |
| try { |
| isCyclicDecision = true; |
| alt133 = dfa133.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(133);} |
| |
| switch (alt133) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix |
| { |
| dbg.location(1105,10); |
| pushFollow(FOLLOW_identifierSuffix_in_primary6356); |
| identifierSuffix(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(133);} |
| |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1107:9: IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? |
| { |
| dbg.location(1107,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6377); if (state.failed) return ; |
| dbg.location(1108,9); |
| // src/com/google/doclava/parser/Java.g:1108:9: ( '.' IDENTIFIER )* |
| try { dbg.enterSubRule(134); |
| |
| loop134: |
| do { |
| int alt134=2; |
| try { dbg.enterDecision(134, decisionCanBacktrack[134]); |
| |
| int LA134_0 = input.LA(1); |
| |
| if ( (LA134_0==DOT) ) { |
| int LA134_2 = input.LA(2); |
| |
| if ( (LA134_2==IDENTIFIER) ) { |
| int LA134_3 = input.LA(3); |
| |
| if ( (synpred211_Java()) ) { |
| alt134=1; |
| } |
| |
| |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(134);} |
| |
| switch (alt134) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER |
| { |
| dbg.location(1108,10); |
| match(input,DOT,FOLLOW_DOT_in_primary6388); if (state.failed) return ; |
| dbg.location(1108,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6390); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop134; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(134);} |
| |
| dbg.location(1110,9); |
| // src/com/google/doclava/parser/Java.g:1110:9: ( identifierSuffix )? |
| int alt135=2; |
| try { dbg.enterSubRule(135); |
| try { dbg.enterDecision(135, decisionCanBacktrack[135]); |
| |
| try { |
| isCyclicDecision = true; |
| alt135 = dfa135.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(135);} |
| |
| switch (alt135) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix |
| { |
| dbg.location(1110,10); |
| pushFollow(FOLLOW_identifierSuffix_in_primary6412); |
| identifierSuffix(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(135);} |
| |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:1112:9: 'super' superSuffix |
| { |
| dbg.location(1112,9); |
| match(input,SUPER,FOLLOW_SUPER_in_primary6433); if (state.failed) return ; |
| dbg.location(1113,9); |
| pushFollow(FOLLOW_superSuffix_in_primary6443); |
| superSuffix(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:1114:9: literal |
| { |
| dbg.location(1114,9); |
| pushFollow(FOLLOW_literal_in_primary6453); |
| literal(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 6 : |
| dbg.enterAlt(6); |
| |
| // src/com/google/doclava/parser/Java.g:1115:9: creator |
| { |
| dbg.location(1115,9); |
| pushFollow(FOLLOW_creator_in_primary6463); |
| creator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 7 : |
| dbg.enterAlt(7); |
| |
| // src/com/google/doclava/parser/Java.g:1116:9: primitiveType ( '[' ']' )* '.' 'class' |
| { |
| dbg.location(1116,9); |
| pushFollow(FOLLOW_primitiveType_in_primary6473); |
| primitiveType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1117,9); |
| // src/com/google/doclava/parser/Java.g:1117:9: ( '[' ']' )* |
| try { dbg.enterSubRule(136); |
| |
| loop136: |
| do { |
| int alt136=2; |
| try { dbg.enterDecision(136, decisionCanBacktrack[136]); |
| |
| int LA136_0 = input.LA(1); |
| |
| if ( (LA136_0==LBRACKET) ) { |
| alt136=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(136);} |
| |
| switch (alt136) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1117:10: '[' ']' |
| { |
| dbg.location(1117,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_primary6484); if (state.failed) return ; |
| dbg.location(1117,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_primary6486); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop136; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(136);} |
| |
| dbg.location(1119,9); |
| match(input,DOT,FOLLOW_DOT_in_primary6507); if (state.failed) return ; |
| dbg.location(1119,13); |
| match(input,CLASS,FOLLOW_CLASS_in_primary6509); if (state.failed) return ; |
| |
| } |
| break; |
| case 8 : |
| dbg.enterAlt(8); |
| |
| // src/com/google/doclava/parser/Java.g:1120:9: 'void' '.' 'class' |
| { |
| dbg.location(1120,9); |
| match(input,VOID,FOLLOW_VOID_in_primary6519); if (state.failed) return ; |
| dbg.location(1120,16); |
| match(input,DOT,FOLLOW_DOT_in_primary6521); if (state.failed) return ; |
| dbg.location(1120,20); |
| match(input,CLASS,FOLLOW_CLASS_in_primary6523); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 89, primary_StartIndex); } |
| } |
| dbg.location(1121, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "primary"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "primary" |
| |
| |
| // $ANTLR start "superSuffix" |
| // src/com/google/doclava/parser/Java.g:1124:1: superSuffix : ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? ); |
| public final void superSuffix() throws RecognitionException { |
| int superSuffix_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "superSuffix"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1124, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1125:5: ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? ) |
| int alt140=2; |
| try { dbg.enterDecision(140, decisionCanBacktrack[140]); |
| |
| int LA140_0 = input.LA(1); |
| |
| if ( (LA140_0==LPAREN) ) { |
| alt140=1; |
| } |
| else if ( (LA140_0==DOT) ) { |
| alt140=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 140, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(140);} |
| |
| switch (alt140) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1125:9: arguments |
| { |
| dbg.location(1125,9); |
| pushFollow(FOLLOW_arguments_in_superSuffix6543); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1126:9: '.' ( typeArguments )? IDENTIFIER ( arguments )? |
| { |
| dbg.location(1126,9); |
| match(input,DOT,FOLLOW_DOT_in_superSuffix6553); if (state.failed) return ; |
| dbg.location(1126,13); |
| // src/com/google/doclava/parser/Java.g:1126:13: ( typeArguments )? |
| int alt138=2; |
| try { dbg.enterSubRule(138); |
| try { dbg.enterDecision(138, decisionCanBacktrack[138]); |
| |
| int LA138_0 = input.LA(1); |
| |
| if ( (LA138_0==LT) ) { |
| alt138=1; |
| } |
| } finally {dbg.exitDecision(138);} |
| |
| switch (alt138) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1126:14: typeArguments |
| { |
| dbg.location(1126,14); |
| pushFollow(FOLLOW_typeArguments_in_superSuffix6556); |
| typeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(138);} |
| |
| dbg.location(1128,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_superSuffix6577); if (state.failed) return ; |
| dbg.location(1129,9); |
| // src/com/google/doclava/parser/Java.g:1129:9: ( arguments )? |
| int alt139=2; |
| try { dbg.enterSubRule(139); |
| try { dbg.enterDecision(139, decisionCanBacktrack[139]); |
| |
| int LA139_0 = input.LA(1); |
| |
| if ( (LA139_0==LPAREN) ) { |
| alt139=1; |
| } |
| } finally {dbg.exitDecision(139);} |
| |
| switch (alt139) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1129:10: arguments |
| { |
| dbg.location(1129,10); |
| pushFollow(FOLLOW_arguments_in_superSuffix6588); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(139);} |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 90, superSuffix_StartIndex); } |
| } |
| dbg.location(1131, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "superSuffix"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "superSuffix" |
| |
| |
| // $ANTLR start "identifierSuffix" |
| // src/com/google/doclava/parser/Java.g:1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator ); |
| public final void identifierSuffix() throws RecognitionException { |
| int identifierSuffix_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "identifierSuffix"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1134, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1135:5: ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator ) |
| int alt143=8; |
| try { dbg.enterDecision(143, decisionCanBacktrack[143]); |
| |
| try { |
| isCyclicDecision = true; |
| alt143 = dfa143.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(143);} |
| |
| switch (alt143) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+ '.' 'class' |
| { |
| dbg.location(1135,9); |
| // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+ |
| int cnt141=0; |
| try { dbg.enterSubRule(141); |
| |
| loop141: |
| do { |
| int alt141=2; |
| try { dbg.enterDecision(141, decisionCanBacktrack[141]); |
| |
| int LA141_0 = input.LA(1); |
| |
| if ( (LA141_0==LBRACKET) ) { |
| alt141=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(141);} |
| |
| switch (alt141) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1135:10: '[' ']' |
| { |
| dbg.location(1135,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6620); if (state.failed) return ; |
| dbg.location(1135,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6622); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| if ( cnt141 >= 1 ) break loop141; |
| if (state.backtracking>0) {state.failed=true; return ;} |
| EarlyExitException eee = |
| new EarlyExitException(141, input); |
| dbg.recognitionException(eee); |
| |
| throw eee; |
| } |
| cnt141++; |
| } while (true); |
| } finally {dbg.exitSubRule(141);} |
| |
| dbg.location(1137,9); |
| match(input,DOT,FOLLOW_DOT_in_identifierSuffix6643); if (state.failed) return ; |
| dbg.location(1137,13); |
| match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6645); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+ |
| { |
| dbg.location(1138,9); |
| // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+ |
| int cnt142=0; |
| try { dbg.enterSubRule(142); |
| |
| loop142: |
| do { |
| int alt142=2; |
| try { dbg.enterDecision(142, decisionCanBacktrack[142]); |
| |
| try { |
| isCyclicDecision = true; |
| alt142 = dfa142.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(142);} |
| |
| switch (alt142) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']' |
| { |
| dbg.location(1138,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6656); if (state.failed) return ; |
| dbg.location(1138,14); |
| pushFollow(FOLLOW_expression_in_identifierSuffix6658); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1138,25); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6660); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| if ( cnt142 >= 1 ) break loop142; |
| if (state.backtracking>0) {state.failed=true; return ;} |
| EarlyExitException eee = |
| new EarlyExitException(142, input); |
| dbg.recognitionException(eee); |
| |
| throw eee; |
| } |
| cnt142++; |
| } while (true); |
| } finally {dbg.exitSubRule(142);} |
| |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1140:9: arguments |
| { |
| dbg.location(1140,9); |
| pushFollow(FOLLOW_arguments_in_identifierSuffix6681); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:1141:9: '.' 'class' |
| { |
| dbg.location(1141,9); |
| match(input,DOT,FOLLOW_DOT_in_identifierSuffix6691); if (state.failed) return ; |
| dbg.location(1141,13); |
| match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6693); if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:1142:9: '.' nonWildcardTypeArguments IDENTIFIER arguments |
| { |
| dbg.location(1142,9); |
| match(input,DOT,FOLLOW_DOT_in_identifierSuffix6703); if (state.failed) return ; |
| dbg.location(1142,13); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1142,38); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierSuffix6707); if (state.failed) return ; |
| dbg.location(1142,49); |
| pushFollow(FOLLOW_arguments_in_identifierSuffix6709); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 6 : |
| dbg.enterAlt(6); |
| |
| // src/com/google/doclava/parser/Java.g:1143:9: '.' 'this' |
| { |
| dbg.location(1143,9); |
| match(input,DOT,FOLLOW_DOT_in_identifierSuffix6719); if (state.failed) return ; |
| dbg.location(1143,13); |
| match(input,THIS,FOLLOW_THIS_in_identifierSuffix6721); if (state.failed) return ; |
| |
| } |
| break; |
| case 7 : |
| dbg.enterAlt(7); |
| |
| // src/com/google/doclava/parser/Java.g:1144:9: '.' 'super' arguments |
| { |
| dbg.location(1144,9); |
| match(input,DOT,FOLLOW_DOT_in_identifierSuffix6731); if (state.failed) return ; |
| dbg.location(1144,13); |
| match(input,SUPER,FOLLOW_SUPER_in_identifierSuffix6733); if (state.failed) return ; |
| dbg.location(1144,21); |
| pushFollow(FOLLOW_arguments_in_identifierSuffix6735); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 8 : |
| dbg.enterAlt(8); |
| |
| // src/com/google/doclava/parser/Java.g:1145:9: innerCreator |
| { |
| dbg.location(1145,9); |
| pushFollow(FOLLOW_innerCreator_in_identifierSuffix6745); |
| innerCreator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 91, identifierSuffix_StartIndex); } |
| } |
| dbg.location(1146, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "identifierSuffix"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "identifierSuffix" |
| |
| |
| // $ANTLR start "selector" |
| // src/com/google/doclava/parser/Java.g:1149:1: selector : ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' ); |
| public final void selector() throws RecognitionException { |
| int selector_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "selector"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1149, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1150:5: ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' ) |
| int alt145=5; |
| try { dbg.enterDecision(145, decisionCanBacktrack[145]); |
| |
| int LA145_0 = input.LA(1); |
| |
| if ( (LA145_0==DOT) ) { |
| switch ( input.LA(2) ) { |
| case IDENTIFIER: |
| { |
| alt145=1; |
| } |
| break; |
| case THIS: |
| { |
| alt145=2; |
| } |
| break; |
| case SUPER: |
| { |
| alt145=3; |
| } |
| break; |
| case NEW: |
| { |
| alt145=4; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 145, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } |
| else if ( (LA145_0==LBRACKET) ) { |
| alt145=5; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 145, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(145);} |
| |
| switch (alt145) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1150:9: '.' IDENTIFIER ( arguments )? |
| { |
| dbg.location(1150,9); |
| match(input,DOT,FOLLOW_DOT_in_selector6765); if (state.failed) return ; |
| dbg.location(1150,13); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_selector6767); if (state.failed) return ; |
| dbg.location(1151,9); |
| // src/com/google/doclava/parser/Java.g:1151:9: ( arguments )? |
| int alt144=2; |
| try { dbg.enterSubRule(144); |
| try { dbg.enterDecision(144, decisionCanBacktrack[144]); |
| |
| int LA144_0 = input.LA(1); |
| |
| if ( (LA144_0==LPAREN) ) { |
| alt144=1; |
| } |
| } finally {dbg.exitDecision(144);} |
| |
| switch (alt144) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1151:10: arguments |
| { |
| dbg.location(1151,10); |
| pushFollow(FOLLOW_arguments_in_selector6778); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(144);} |
| |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1153:9: '.' 'this' |
| { |
| dbg.location(1153,9); |
| match(input,DOT,FOLLOW_DOT_in_selector6799); if (state.failed) return ; |
| dbg.location(1153,13); |
| match(input,THIS,FOLLOW_THIS_in_selector6801); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1154:9: '.' 'super' superSuffix |
| { |
| dbg.location(1154,9); |
| match(input,DOT,FOLLOW_DOT_in_selector6811); if (state.failed) return ; |
| dbg.location(1154,13); |
| match(input,SUPER,FOLLOW_SUPER_in_selector6813); if (state.failed) return ; |
| dbg.location(1155,9); |
| pushFollow(FOLLOW_superSuffix_in_selector6823); |
| superSuffix(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 4 : |
| dbg.enterAlt(4); |
| |
| // src/com/google/doclava/parser/Java.g:1156:9: innerCreator |
| { |
| dbg.location(1156,9); |
| pushFollow(FOLLOW_innerCreator_in_selector6833); |
| innerCreator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 5 : |
| dbg.enterAlt(5); |
| |
| // src/com/google/doclava/parser/Java.g:1157:9: '[' expression ']' |
| { |
| dbg.location(1157,9); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_selector6843); if (state.failed) return ; |
| dbg.location(1157,13); |
| pushFollow(FOLLOW_expression_in_selector6845); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1157,24); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_selector6847); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 92, selector_StartIndex); } |
| } |
| dbg.location(1158, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "selector"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "selector" |
| |
| |
| // $ANTLR start "creator" |
| // src/com/google/doclava/parser/Java.g:1160:1: creator : ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator ); |
| public final void creator() throws RecognitionException { |
| int creator_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "creator"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1160, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1161:5: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator ) |
| int alt146=3; |
| try { dbg.enterDecision(146, decisionCanBacktrack[146]); |
| |
| int LA146_0 = input.LA(1); |
| |
| if ( (LA146_0==NEW) ) { |
| int LA146_1 = input.LA(2); |
| |
| if ( (synpred236_Java()) ) { |
| alt146=1; |
| } |
| else if ( (synpred237_Java()) ) { |
| alt146=2; |
| } |
| else if ( (true) ) { |
| alt146=3; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 146, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 146, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(146);} |
| |
| switch (alt146) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest |
| { |
| dbg.location(1161,9); |
| match(input,NEW,FOLLOW_NEW_in_creator6866); if (state.failed) return ; |
| dbg.location(1161,15); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_creator6868); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1161,40); |
| pushFollow(FOLLOW_classOrInterfaceType_in_creator6870); |
| classOrInterfaceType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1161,61); |
| pushFollow(FOLLOW_classCreatorRest_in_creator6872); |
| classCreatorRest(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest |
| { |
| dbg.location(1162,9); |
| match(input,NEW,FOLLOW_NEW_in_creator6882); if (state.failed) return ; |
| dbg.location(1162,15); |
| pushFollow(FOLLOW_classOrInterfaceType_in_creator6884); |
| classOrInterfaceType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1162,36); |
| pushFollow(FOLLOW_classCreatorRest_in_creator6886); |
| classCreatorRest(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1163:9: arrayCreator |
| { |
| dbg.location(1163,9); |
| pushFollow(FOLLOW_arrayCreator_in_creator6896); |
| arrayCreator(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 93, creator_StartIndex); } |
| } |
| dbg.location(1164, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "creator"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "creator" |
| |
| |
| // $ANTLR start "arrayCreator" |
| // src/com/google/doclava/parser/Java.g:1166:1: arrayCreator : ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* ); |
| public final void arrayCreator() throws RecognitionException { |
| int arrayCreator_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "arrayCreator"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1166, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1167:5: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* ) |
| int alt150=2; |
| try { dbg.enterDecision(150, decisionCanBacktrack[150]); |
| |
| int LA150_0 = input.LA(1); |
| |
| if ( (LA150_0==NEW) ) { |
| int LA150_1 = input.LA(2); |
| |
| if ( (synpred239_Java()) ) { |
| alt150=1; |
| } |
| else if ( (true) ) { |
| alt150=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 150, 1, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 150, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(150);} |
| |
| switch (alt150) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer |
| { |
| dbg.location(1167,9); |
| match(input,NEW,FOLLOW_NEW_in_arrayCreator6915); if (state.failed) return ; |
| dbg.location(1167,15); |
| pushFollow(FOLLOW_createdName_in_arrayCreator6917); |
| createdName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1168,9); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6927); if (state.failed) return ; |
| dbg.location(1168,13); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6929); if (state.failed) return ; |
| dbg.location(1169,9); |
| // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )* |
| try { dbg.enterSubRule(147); |
| |
| loop147: |
| do { |
| int alt147=2; |
| try { dbg.enterDecision(147, decisionCanBacktrack[147]); |
| |
| int LA147_0 = input.LA(1); |
| |
| if ( (LA147_0==LBRACKET) ) { |
| alt147=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(147);} |
| |
| switch (alt147) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1169:10: '[' ']' |
| { |
| dbg.location(1169,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6940); if (state.failed) return ; |
| dbg.location(1169,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6942); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop147; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(147);} |
| |
| dbg.location(1171,9); |
| pushFollow(FOLLOW_arrayInitializer_in_arrayCreator6963); |
| arrayInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1173:9: 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* |
| { |
| dbg.location(1173,9); |
| match(input,NEW,FOLLOW_NEW_in_arrayCreator6974); if (state.failed) return ; |
| dbg.location(1173,15); |
| pushFollow(FOLLOW_createdName_in_arrayCreator6976); |
| createdName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1174,9); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6986); if (state.failed) return ; |
| dbg.location(1174,13); |
| pushFollow(FOLLOW_expression_in_arrayCreator6988); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1175,9); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6998); if (state.failed) return ; |
| dbg.location(1176,9); |
| // src/com/google/doclava/parser/Java.g:1176:9: ( '[' expression ']' )* |
| try { dbg.enterSubRule(148); |
| |
| loop148: |
| do { |
| int alt148=2; |
| try { dbg.enterDecision(148, decisionCanBacktrack[148]); |
| |
| try { |
| isCyclicDecision = true; |
| alt148 = dfa148.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(148);} |
| |
| switch (alt148) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']' |
| { |
| dbg.location(1176,13); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7012); if (state.failed) return ; |
| dbg.location(1176,17); |
| pushFollow(FOLLOW_expression_in_arrayCreator7014); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1177,13); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7028); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop148; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(148);} |
| |
| dbg.location(1179,9); |
| // src/com/google/doclava/parser/Java.g:1179:9: ( '[' ']' )* |
| try { dbg.enterSubRule(149); |
| |
| loop149: |
| do { |
| int alt149=2; |
| try { dbg.enterDecision(149, decisionCanBacktrack[149]); |
| |
| int LA149_0 = input.LA(1); |
| |
| if ( (LA149_0==LBRACKET) ) { |
| int LA149_2 = input.LA(2); |
| |
| if ( (LA149_2==RBRACKET) ) { |
| alt149=1; |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(149);} |
| |
| switch (alt149) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1179:10: '[' ']' |
| { |
| dbg.location(1179,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7050); if (state.failed) return ; |
| dbg.location(1179,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7052); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop149; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(149);} |
| |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 94, arrayCreator_StartIndex); } |
| } |
| dbg.location(1181, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "arrayCreator"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "arrayCreator" |
| |
| |
| // $ANTLR start "variableInitializer" |
| // src/com/google/doclava/parser/Java.g:1183:1: variableInitializer : ( arrayInitializer | expression ); |
| public final void variableInitializer() throws RecognitionException { |
| int variableInitializer_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "variableInitializer"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1183, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1184:5: ( arrayInitializer | expression ) |
| int alt151=2; |
| try { dbg.enterDecision(151, decisionCanBacktrack[151]); |
| |
| int LA151_0 = input.LA(1); |
| |
| if ( (LA151_0==LBRACE) ) { |
| alt151=1; |
| } |
| else if ( ((LA151_0>=IDENTIFIER && LA151_0<=NULL)||LA151_0==BOOLEAN||LA151_0==BYTE||LA151_0==CHAR||LA151_0==DOUBLE||LA151_0==FLOAT||LA151_0==INT||LA151_0==LONG||LA151_0==NEW||LA151_0==SHORT||LA151_0==SUPER||LA151_0==THIS||LA151_0==VOID||LA151_0==LPAREN||(LA151_0>=BANG && LA151_0<=TILDE)||(LA151_0>=PLUSPLUS && LA151_0<=SUB)) ) { |
| alt151=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 151, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(151);} |
| |
| switch (alt151) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1184:9: arrayInitializer |
| { |
| dbg.location(1184,9); |
| pushFollow(FOLLOW_arrayInitializer_in_variableInitializer7082); |
| arrayInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1185:9: expression |
| { |
| dbg.location(1185,9); |
| pushFollow(FOLLOW_expression_in_variableInitializer7092); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 95, variableInitializer_StartIndex); } |
| } |
| dbg.location(1186, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "variableInitializer"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "variableInitializer" |
| |
| |
| // $ANTLR start "arrayInitializer" |
| // src/com/google/doclava/parser/Java.g:1188:1: arrayInitializer : '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ; |
| public final void arrayInitializer() throws RecognitionException { |
| int arrayInitializer_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "arrayInitializer"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1188, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1189:5: ( '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1189:9: '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' |
| { |
| dbg.location(1189,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_arrayInitializer7111); if (state.failed) return ; |
| dbg.location(1190,13); |
| // src/com/google/doclava/parser/Java.g:1190:13: ( variableInitializer ( ',' variableInitializer )* )? |
| int alt153=2; |
| try { dbg.enterSubRule(153); |
| try { dbg.enterDecision(153, decisionCanBacktrack[153]); |
| |
| int LA153_0 = input.LA(1); |
| |
| if ( ((LA153_0>=IDENTIFIER && LA153_0<=NULL)||LA153_0==BOOLEAN||LA153_0==BYTE||LA153_0==CHAR||LA153_0==DOUBLE||LA153_0==FLOAT||LA153_0==INT||LA153_0==LONG||LA153_0==NEW||LA153_0==SHORT||LA153_0==SUPER||LA153_0==THIS||LA153_0==VOID||LA153_0==LPAREN||LA153_0==LBRACE||(LA153_0>=BANG && LA153_0<=TILDE)||(LA153_0>=PLUSPLUS && LA153_0<=SUB)) ) { |
| alt153=1; |
| } |
| } finally {dbg.exitDecision(153);} |
| |
| switch (alt153) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1190:14: variableInitializer ( ',' variableInitializer )* |
| { |
| dbg.location(1190,14); |
| pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7126); |
| variableInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1191,17); |
| // src/com/google/doclava/parser/Java.g:1191:17: ( ',' variableInitializer )* |
| try { dbg.enterSubRule(152); |
| |
| loop152: |
| do { |
| int alt152=2; |
| try { dbg.enterDecision(152, decisionCanBacktrack[152]); |
| |
| int LA152_0 = input.LA(1); |
| |
| if ( (LA152_0==COMMA) ) { |
| int LA152_1 = input.LA(2); |
| |
| if ( ((LA152_1>=IDENTIFIER && LA152_1<=NULL)||LA152_1==BOOLEAN||LA152_1==BYTE||LA152_1==CHAR||LA152_1==DOUBLE||LA152_1==FLOAT||LA152_1==INT||LA152_1==LONG||LA152_1==NEW||LA152_1==SHORT||LA152_1==SUPER||LA152_1==THIS||LA152_1==VOID||LA152_1==LPAREN||LA152_1==LBRACE||(LA152_1>=BANG && LA152_1<=TILDE)||(LA152_1>=PLUSPLUS && LA152_1<=SUB)) ) { |
| alt152=1; |
| } |
| |
| |
| } |
| |
| |
| } finally {dbg.exitDecision(152);} |
| |
| switch (alt152) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1191:18: ',' variableInitializer |
| { |
| dbg.location(1191,18); |
| match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7145); if (state.failed) return ; |
| dbg.location(1191,22); |
| pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7147); |
| variableInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop152; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(152);} |
| |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(153);} |
| |
| dbg.location(1194,13); |
| // src/com/google/doclava/parser/Java.g:1194:13: ( ',' )? |
| int alt154=2; |
| try { dbg.enterSubRule(154); |
| try { dbg.enterDecision(154, decisionCanBacktrack[154]); |
| |
| int LA154_0 = input.LA(1); |
| |
| if ( (LA154_0==COMMA) ) { |
| alt154=1; |
| } |
| } finally {dbg.exitDecision(154);} |
| |
| switch (alt154) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1194:14: ',' |
| { |
| dbg.location(1194,14); |
| match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7196); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(154);} |
| |
| dbg.location(1195,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_arrayInitializer7208); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 96, arrayInitializer_StartIndex); } |
| } |
| dbg.location(1196, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "arrayInitializer"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "arrayInitializer" |
| |
| |
| // $ANTLR start "createdName" |
| // src/com/google/doclava/parser/Java.g:1199:1: createdName : ( classOrInterfaceType | primitiveType ); |
| public final void createdName() throws RecognitionException { |
| int createdName_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "createdName"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1199, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1200:5: ( classOrInterfaceType | primitiveType ) |
| int alt155=2; |
| try { dbg.enterDecision(155, decisionCanBacktrack[155]); |
| |
| int LA155_0 = input.LA(1); |
| |
| if ( (LA155_0==IDENTIFIER) ) { |
| alt155=1; |
| } |
| else if ( (LA155_0==BOOLEAN||LA155_0==BYTE||LA155_0==CHAR||LA155_0==DOUBLE||LA155_0==FLOAT||LA155_0==INT||LA155_0==LONG||LA155_0==SHORT) ) { |
| alt155=2; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 155, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(155);} |
| |
| switch (alt155) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1200:9: classOrInterfaceType |
| { |
| dbg.location(1200,9); |
| pushFollow(FOLLOW_classOrInterfaceType_in_createdName7241); |
| classOrInterfaceType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1201:9: primitiveType |
| { |
| dbg.location(1201,9); |
| pushFollow(FOLLOW_primitiveType_in_createdName7251); |
| primitiveType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 97, createdName_StartIndex); } |
| } |
| dbg.location(1202, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "createdName"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "createdName" |
| |
| |
| // $ANTLR start "innerCreator" |
| // src/com/google/doclava/parser/Java.g:1204:1: innerCreator : '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ; |
| public final void innerCreator() throws RecognitionException { |
| int innerCreator_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "innerCreator"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1204, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1205:5: ( '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1205:9: '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest |
| { |
| dbg.location(1205,9); |
| match(input,DOT,FOLLOW_DOT_in_innerCreator7270); if (state.failed) return ; |
| dbg.location(1205,13); |
| match(input,NEW,FOLLOW_NEW_in_innerCreator7272); if (state.failed) return ; |
| dbg.location(1206,9); |
| // src/com/google/doclava/parser/Java.g:1206:9: ( nonWildcardTypeArguments )? |
| int alt156=2; |
| try { dbg.enterSubRule(156); |
| try { dbg.enterDecision(156, decisionCanBacktrack[156]); |
| |
| int LA156_0 = input.LA(1); |
| |
| if ( (LA156_0==LT) ) { |
| alt156=1; |
| } |
| } finally {dbg.exitDecision(156);} |
| |
| switch (alt156) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1206:10: nonWildcardTypeArguments |
| { |
| dbg.location(1206,10); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_innerCreator7283); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(156);} |
| |
| dbg.location(1208,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_innerCreator7304); if (state.failed) return ; |
| dbg.location(1209,9); |
| // src/com/google/doclava/parser/Java.g:1209:9: ( typeArguments )? |
| int alt157=2; |
| try { dbg.enterSubRule(157); |
| try { dbg.enterDecision(157, decisionCanBacktrack[157]); |
| |
| int LA157_0 = input.LA(1); |
| |
| if ( (LA157_0==LT) ) { |
| alt157=1; |
| } |
| } finally {dbg.exitDecision(157);} |
| |
| switch (alt157) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1209:10: typeArguments |
| { |
| dbg.location(1209,10); |
| pushFollow(FOLLOW_typeArguments_in_innerCreator7315); |
| typeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(157);} |
| |
| dbg.location(1211,9); |
| pushFollow(FOLLOW_classCreatorRest_in_innerCreator7336); |
| classCreatorRest(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 98, innerCreator_StartIndex); } |
| } |
| dbg.location(1212, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "innerCreator"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "innerCreator" |
| |
| |
| // $ANTLR start "classCreatorRest" |
| // src/com/google/doclava/parser/Java.g:1215:1: classCreatorRest : arguments ( classBody )? ; |
| public final void classCreatorRest() throws RecognitionException { |
| int classCreatorRest_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classCreatorRest"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1215, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1216:5: ( arguments ( classBody )? ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1216:9: arguments ( classBody )? |
| { |
| dbg.location(1216,9); |
| pushFollow(FOLLOW_arguments_in_classCreatorRest7356); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1217,9); |
| // src/com/google/doclava/parser/Java.g:1217:9: ( classBody )? |
| int alt158=2; |
| try { dbg.enterSubRule(158); |
| try { dbg.enterDecision(158, decisionCanBacktrack[158]); |
| |
| int LA158_0 = input.LA(1); |
| |
| if ( (LA158_0==LBRACE) ) { |
| alt158=1; |
| } |
| } finally {dbg.exitDecision(158);} |
| |
| switch (alt158) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1217:10: classBody |
| { |
| dbg.location(1217,10); |
| pushFollow(FOLLOW_classBody_in_classCreatorRest7367); |
| classBody(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(158);} |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 99, classCreatorRest_StartIndex); } |
| } |
| dbg.location(1219, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classCreatorRest"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classCreatorRest" |
| |
| |
| // $ANTLR start "nonWildcardTypeArguments" |
| // src/com/google/doclava/parser/Java.g:1222:1: nonWildcardTypeArguments : '<' typeList '>' ; |
| public final void nonWildcardTypeArguments() throws RecognitionException { |
| int nonWildcardTypeArguments_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "nonWildcardTypeArguments"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1222, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1223:5: ( '<' typeList '>' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1223:9: '<' typeList '>' |
| { |
| dbg.location(1223,9); |
| match(input,LT,FOLLOW_LT_in_nonWildcardTypeArguments7398); if (state.failed) return ; |
| dbg.location(1223,13); |
| pushFollow(FOLLOW_typeList_in_nonWildcardTypeArguments7400); |
| typeList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1224,9); |
| match(input,GT,FOLLOW_GT_in_nonWildcardTypeArguments7410); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 100, nonWildcardTypeArguments_StartIndex); } |
| } |
| dbg.location(1225, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "nonWildcardTypeArguments"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "nonWildcardTypeArguments" |
| |
| |
| // $ANTLR start "arguments" |
| // src/com/google/doclava/parser/Java.g:1227:1: arguments : '(' ( expressionList )? ')' ; |
| public final void arguments() throws RecognitionException { |
| int arguments_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "arguments"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1227, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1228:5: ( '(' ( expressionList )? ')' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1228:9: '(' ( expressionList )? ')' |
| { |
| dbg.location(1228,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_arguments7429); if (state.failed) return ; |
| dbg.location(1228,13); |
| // src/com/google/doclava/parser/Java.g:1228:13: ( expressionList )? |
| int alt159=2; |
| try { dbg.enterSubRule(159); |
| try { dbg.enterDecision(159, decisionCanBacktrack[159]); |
| |
| int LA159_0 = input.LA(1); |
| |
| if ( ((LA159_0>=IDENTIFIER && LA159_0<=NULL)||LA159_0==BOOLEAN||LA159_0==BYTE||LA159_0==CHAR||LA159_0==DOUBLE||LA159_0==FLOAT||LA159_0==INT||LA159_0==LONG||LA159_0==NEW||LA159_0==SHORT||LA159_0==SUPER||LA159_0==THIS||LA159_0==VOID||LA159_0==LPAREN||(LA159_0>=BANG && LA159_0<=TILDE)||(LA159_0>=PLUSPLUS && LA159_0<=SUB)) ) { |
| alt159=1; |
| } |
| } finally {dbg.exitDecision(159);} |
| |
| switch (alt159) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1228:14: expressionList |
| { |
| dbg.location(1228,14); |
| pushFollow(FOLLOW_expressionList_in_arguments7432); |
| expressionList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(159);} |
| |
| dbg.location(1229,12); |
| match(input,RPAREN,FOLLOW_RPAREN_in_arguments7445); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 101, arguments_StartIndex); } |
| } |
| dbg.location(1230, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "arguments"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "arguments" |
| |
| |
| // $ANTLR start "literal" |
| // src/com/google/doclava/parser/Java.g:1232:1: literal : ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL ); |
| public final void literal() throws RecognitionException { |
| int literal_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "literal"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1232, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1233:5: ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g: |
| { |
| dbg.location(1233,5); |
| if ( (input.LA(1)>=INTLITERAL && input.LA(1)<=NULL) ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 102, literal_StartIndex); } |
| } |
| dbg.location(1242, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "literal"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "literal" |
| |
| |
| // $ANTLR start "classHeader" |
| // src/com/google/doclava/parser/Java.g:1244:1: classHeader : modifiers 'class' IDENTIFIER ; |
| public final void classHeader() throws RecognitionException { |
| int classHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "classHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1244, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1249:5: ( modifiers 'class' IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1249:9: modifiers 'class' IDENTIFIER |
| { |
| dbg.location(1249,9); |
| pushFollow(FOLLOW_modifiers_in_classHeader7566); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1249,19); |
| match(input,CLASS,FOLLOW_CLASS_in_classHeader7568); if (state.failed) return ; |
| dbg.location(1249,27); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classHeader7570); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 103, classHeader_StartIndex); } |
| } |
| dbg.location(1250, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "classHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "classHeader" |
| |
| |
| // $ANTLR start "enumHeader" |
| // src/com/google/doclava/parser/Java.g:1252:1: enumHeader : modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ; |
| public final void enumHeader() throws RecognitionException { |
| int enumHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "enumHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1252, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1253:5: ( modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1253:9: modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER |
| { |
| dbg.location(1253,9); |
| pushFollow(FOLLOW_modifiers_in_enumHeader7589); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1253,19); |
| if ( input.LA(1)==IDENTIFIER||input.LA(1)==ENUM ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(1253,39); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader7597); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 104, enumHeader_StartIndex); } |
| } |
| dbg.location(1254, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "enumHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "enumHeader" |
| |
| |
| // $ANTLR start "interfaceHeader" |
| // src/com/google/doclava/parser/Java.g:1256:1: interfaceHeader : modifiers 'interface' IDENTIFIER ; |
| public final void interfaceHeader() throws RecognitionException { |
| int interfaceHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "interfaceHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1256, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1257:5: ( modifiers 'interface' IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1257:9: modifiers 'interface' IDENTIFIER |
| { |
| dbg.location(1257,9); |
| pushFollow(FOLLOW_modifiers_in_interfaceHeader7616); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1257,19); |
| match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceHeader7618); if (state.failed) return ; |
| dbg.location(1257,31); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceHeader7620); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 105, interfaceHeader_StartIndex); } |
| } |
| dbg.location(1258, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "interfaceHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "interfaceHeader" |
| |
| |
| // $ANTLR start "annotationHeader" |
| // src/com/google/doclava/parser/Java.g:1260:1: annotationHeader : modifiers '@' 'interface' IDENTIFIER ; |
| public final void annotationHeader() throws RecognitionException { |
| int annotationHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "annotationHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1260, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1261:5: ( modifiers '@' 'interface' IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1261:9: modifiers '@' 'interface' IDENTIFIER |
| { |
| dbg.location(1261,9); |
| pushFollow(FOLLOW_modifiers_in_annotationHeader7639); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1261,19); |
| match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationHeader7641); if (state.failed) return ; |
| dbg.location(1261,23); |
| match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationHeader7643); if (state.failed) return ; |
| dbg.location(1261,35); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationHeader7645); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 106, annotationHeader_StartIndex); } |
| } |
| dbg.location(1262, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "annotationHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "annotationHeader" |
| |
| |
| // $ANTLR start "typeHeader" |
| // src/com/google/doclava/parser/Java.g:1264:1: typeHeader : modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ; |
| public final void typeHeader() throws RecognitionException { |
| int typeHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "typeHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1264, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1265:5: ( modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1265:9: modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER |
| { |
| dbg.location(1265,9); |
| pushFollow(FOLLOW_modifiers_in_typeHeader7664); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1265,19); |
| // src/com/google/doclava/parser/Java.g:1265:19: ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) |
| int alt161=3; |
| try { dbg.enterSubRule(161); |
| try { dbg.enterDecision(161, decisionCanBacktrack[161]); |
| |
| switch ( input.LA(1) ) { |
| case CLASS: |
| { |
| alt161=1; |
| } |
| break; |
| case ENUM: |
| { |
| alt161=2; |
| } |
| break; |
| case INTERFACE: |
| case MONKEYS_AT: |
| { |
| alt161=3; |
| } |
| break; |
| default: |
| if (state.backtracking>0) {state.failed=true; return ;} |
| NoViableAltException nvae = |
| new NoViableAltException("", 161, 0, input); |
| |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| |
| } finally {dbg.exitDecision(161);} |
| |
| switch (alt161) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1265:20: 'class' |
| { |
| dbg.location(1265,20); |
| match(input,CLASS,FOLLOW_CLASS_in_typeHeader7667); if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1265:28: 'enum' |
| { |
| dbg.location(1265,28); |
| match(input,ENUM,FOLLOW_ENUM_in_typeHeader7669); if (state.failed) return ; |
| |
| } |
| break; |
| case 3 : |
| dbg.enterAlt(3); |
| |
| // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' ) |
| { |
| dbg.location(1265,35); |
| // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )? 'interface' |
| { |
| dbg.location(1265,36); |
| // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )? |
| int alt160=2; |
| try { dbg.enterSubRule(160); |
| try { dbg.enterDecision(160, decisionCanBacktrack[160]); |
| |
| int LA160_0 = input.LA(1); |
| |
| if ( (LA160_0==MONKEYS_AT) ) { |
| alt160=1; |
| } |
| } finally {dbg.exitDecision(160);} |
| |
| switch (alt160) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:0:0: '@' |
| { |
| dbg.location(1265,36); |
| match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_typeHeader7672); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(160);} |
| |
| dbg.location(1265,42); |
| match(input,INTERFACE,FOLLOW_INTERFACE_in_typeHeader7676); if (state.failed) return ; |
| |
| } |
| |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(161);} |
| |
| dbg.location(1265,56); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeHeader7680); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 107, typeHeader_StartIndex); } |
| } |
| dbg.location(1266, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "typeHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "typeHeader" |
| |
| |
| // $ANTLR start "methodHeader" |
| // src/com/google/doclava/parser/Java.g:1268:1: methodHeader : modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ; |
| public final void methodHeader() throws RecognitionException { |
| int methodHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "methodHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1268, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1269:5: ( modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1269:9: modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' |
| { |
| dbg.location(1269,9); |
| pushFollow(FOLLOW_modifiers_in_methodHeader7699); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1269,19); |
| // src/com/google/doclava/parser/Java.g:1269:19: ( typeParameters )? |
| int alt162=2; |
| try { dbg.enterSubRule(162); |
| try { dbg.enterDecision(162, decisionCanBacktrack[162]); |
| |
| int LA162_0 = input.LA(1); |
| |
| if ( (LA162_0==LT) ) { |
| alt162=1; |
| } |
| } finally {dbg.exitDecision(162);} |
| |
| switch (alt162) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:0:0: typeParameters |
| { |
| dbg.location(1269,19); |
| pushFollow(FOLLOW_typeParameters_in_methodHeader7701); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(162);} |
| |
| dbg.location(1269,35); |
| // src/com/google/doclava/parser/Java.g:1269:35: ( type | 'void' )? |
| int alt163=3; |
| try { dbg.enterSubRule(163); |
| try { dbg.enterDecision(163, decisionCanBacktrack[163]); |
| |
| switch ( input.LA(1) ) { |
| case IDENTIFIER: |
| { |
| int LA163_1 = input.LA(2); |
| |
| if ( (LA163_1==IDENTIFIER||LA163_1==LBRACKET||LA163_1==DOT||LA163_1==LT) ) { |
| alt163=1; |
| } |
| } |
| break; |
| case BOOLEAN: |
| case BYTE: |
| case CHAR: |
| case DOUBLE: |
| case FLOAT: |
| case INT: |
| case LONG: |
| case SHORT: |
| { |
| alt163=1; |
| } |
| break; |
| case VOID: |
| { |
| alt163=2; |
| } |
| break; |
| } |
| |
| } finally {dbg.exitDecision(163);} |
| |
| switch (alt163) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1269:36: type |
| { |
| dbg.location(1269,36); |
| pushFollow(FOLLOW_type_in_methodHeader7705); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| case 2 : |
| dbg.enterAlt(2); |
| |
| // src/com/google/doclava/parser/Java.g:1269:41: 'void' |
| { |
| dbg.location(1269,41); |
| match(input,VOID,FOLLOW_VOID_in_methodHeader7707); if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(163);} |
| |
| dbg.location(1269,50); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodHeader7711); if (state.failed) return ; |
| dbg.location(1269,61); |
| match(input,LPAREN,FOLLOW_LPAREN_in_methodHeader7713); if (state.failed) return ; |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 108, methodHeader_StartIndex); } |
| } |
| dbg.location(1270, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "methodHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "methodHeader" |
| |
| |
| // $ANTLR start "fieldHeader" |
| // src/com/google/doclava/parser/Java.g:1272:1: fieldHeader : modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ; |
| public final void fieldHeader() throws RecognitionException { |
| int fieldHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "fieldHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1272, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1273:5: ( modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1273:9: modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) |
| { |
| dbg.location(1273,9); |
| pushFollow(FOLLOW_modifiers_in_fieldHeader7732); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1273,19); |
| pushFollow(FOLLOW_type_in_fieldHeader7734); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1273,24); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_fieldHeader7736); if (state.failed) return ; |
| dbg.location(1273,35); |
| // src/com/google/doclava/parser/Java.g:1273:35: ( '[' ']' )* |
| try { dbg.enterSubRule(164); |
| |
| loop164: |
| do { |
| int alt164=2; |
| try { dbg.enterDecision(164, decisionCanBacktrack[164]); |
| |
| int LA164_0 = input.LA(1); |
| |
| if ( (LA164_0==LBRACKET) ) { |
| alt164=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(164);} |
| |
| switch (alt164) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1273:36: '[' ']' |
| { |
| dbg.location(1273,36); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_fieldHeader7739); if (state.failed) return ; |
| dbg.location(1273,39); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_fieldHeader7740); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop164; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(164);} |
| |
| dbg.location(1273,45); |
| if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 109, fieldHeader_StartIndex); } |
| } |
| dbg.location(1274, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "fieldHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "fieldHeader" |
| |
| |
| // $ANTLR start "localVariableHeader" |
| // src/com/google/doclava/parser/Java.g:1276:1: localVariableHeader : variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ; |
| public final void localVariableHeader() throws RecognitionException { |
| int localVariableHeader_StartIndex = input.index(); |
| try { dbg.enterRule(getGrammarFileName(), "localVariableHeader"); |
| if ( getRuleLevel()==0 ) {dbg.commence();} |
| incRuleLevel(); |
| dbg.location(1276, 1); |
| |
| try { |
| if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return ; } |
| // src/com/google/doclava/parser/Java.g:1277:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1277:9: variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) |
| { |
| dbg.location(1277,9); |
| pushFollow(FOLLOW_variableModifiers_in_localVariableHeader7769); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1277,27); |
| pushFollow(FOLLOW_type_in_localVariableHeader7771); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1277,32); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_localVariableHeader7773); if (state.failed) return ; |
| dbg.location(1277,43); |
| // src/com/google/doclava/parser/Java.g:1277:43: ( '[' ']' )* |
| try { dbg.enterSubRule(165); |
| |
| loop165: |
| do { |
| int alt165=2; |
| try { dbg.enterDecision(165, decisionCanBacktrack[165]); |
| |
| int LA165_0 = input.LA(1); |
| |
| if ( (LA165_0==LBRACKET) ) { |
| alt165=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(165);} |
| |
| switch (alt165) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1277:44: '[' ']' |
| { |
| dbg.location(1277,44); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_localVariableHeader7776); if (state.failed) return ; |
| dbg.location(1277,47); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_localVariableHeader7777); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop165; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(165);} |
| |
| dbg.location(1277,53); |
| if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| |
| } |
| |
| } |
| catch (RecognitionException re) { |
| reportError(re); |
| recover(input,re); |
| } |
| finally { |
| if ( state.backtracking>0 ) { memoize(input, 110, localVariableHeader_StartIndex); } |
| } |
| dbg.location(1278, 5); |
| |
| } |
| finally { |
| dbg.exitRule(getGrammarFileName(), "localVariableHeader"); |
| decRuleLevel(); |
| if ( getRuleLevel()==0 ) {dbg.terminate();} |
| } |
| |
| return ; |
| } |
| // $ANTLR end "localVariableHeader" |
| |
| // $ANTLR start synpred2_Java |
| public final void synpred2_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:298:13: ( ( annotations )? packageDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration |
| { |
| dbg.location(298,13); |
| // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? |
| int alt166=2; |
| try { dbg.enterSubRule(166); |
| try { dbg.enterDecision(166, decisionCanBacktrack[166]); |
| |
| int LA166_0 = input.LA(1); |
| |
| if ( (LA166_0==MONKEYS_AT) ) { |
| alt166=1; |
| } |
| } finally {dbg.exitDecision(166);} |
| |
| switch (alt166) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:298:14: annotations |
| { |
| dbg.location(298,14); |
| pushFollow(FOLLOW_annotations_in_synpred2_Java64); |
| annotations(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(166);} |
| |
| dbg.location(300,13); |
| pushFollow(FOLLOW_packageDeclaration_in_synpred2_Java93); |
| packageDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred2_Java |
| |
| // $ANTLR start synpred12_Java |
| public final void synpred12_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:342:10: ( classDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:342:10: classDeclaration |
| { |
| dbg.location(342,10); |
| pushFollow(FOLLOW_classDeclaration_in_synpred12_Java436); |
| classDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred12_Java |
| |
| // $ANTLR start synpred27_Java |
| public final void synpred27_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:373:9: ( normalClassDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration |
| { |
| dbg.location(373,9); |
| pushFollow(FOLLOW_normalClassDeclaration_in_synpred27_Java659); |
| normalClassDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred27_Java |
| |
| // $ANTLR start synpred43_Java |
| public final void synpred43_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:461:9: ( normalInterfaceDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration |
| { |
| dbg.location(461,9); |
| pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306); |
| normalInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred43_Java |
| |
| // $ANTLR start synpred52_Java |
| public final void synpred52_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:503:10: ( fieldDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration |
| { |
| dbg.location(503,10); |
| pushFollow(FOLLOW_fieldDeclaration_in_synpred52_Java1621); |
| fieldDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred52_Java |
| |
| // $ANTLR start synpred53_Java |
| public final void synpred53_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:504:10: ( methodDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration |
| { |
| dbg.location(504,10); |
| pushFollow(FOLLOW_methodDeclaration_in_synpred53_Java1632); |
| methodDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred53_Java |
| |
| // $ANTLR start synpred54_Java |
| public final void synpred54_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:505:10: ( classDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:505:10: classDeclaration |
| { |
| dbg.location(505,10); |
| pushFollow(FOLLOW_classDeclaration_in_synpred54_Java1643); |
| classDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred54_Java |
| |
| // $ANTLR start synpred57_Java |
| public final void synpred57_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:521:10: ( explicitConstructorInvocation ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation |
| { |
| dbg.location(521,10); |
| pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778); |
| explicitConstructorInvocation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred57_Java |
| |
| // $ANTLR start synpred59_Java |
| public final void synpred59_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:513:10: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' |
| { |
| dbg.location(513,10); |
| pushFollow(FOLLOW_modifiers_in_synpred59_Java1691); |
| modifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(514,9); |
| // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )? |
| int alt169=2; |
| try { dbg.enterSubRule(169); |
| try { dbg.enterDecision(169, decisionCanBacktrack[169]); |
| |
| int LA169_0 = input.LA(1); |
| |
| if ( (LA169_0==LT) ) { |
| alt169=1; |
| } |
| } finally {dbg.exitDecision(169);} |
| |
| switch (alt169) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:514:10: typeParameters |
| { |
| dbg.location(514,10); |
| pushFollow(FOLLOW_typeParameters_in_synpred59_Java1702); |
| typeParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(169);} |
| |
| dbg.location(516,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred59_Java1723); if (state.failed) return ; |
| dbg.location(517,9); |
| pushFollow(FOLLOW_formalParameters_in_synpred59_Java1733); |
| formalParameters(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(518,9); |
| // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )? |
| int alt170=2; |
| try { dbg.enterSubRule(170); |
| try { dbg.enterDecision(170, decisionCanBacktrack[170]); |
| |
| int LA170_0 = input.LA(1); |
| |
| if ( (LA170_0==THROWS) ) { |
| alt170=1; |
| } |
| } finally {dbg.exitDecision(170);} |
| |
| switch (alt170) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList |
| { |
| dbg.location(518,10); |
| match(input,THROWS,FOLLOW_THROWS_in_synpred59_Java1744); if (state.failed) return ; |
| dbg.location(518,19); |
| pushFollow(FOLLOW_qualifiedNameList_in_synpred59_Java1746); |
| qualifiedNameList(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(170);} |
| |
| dbg.location(520,9); |
| match(input,LBRACE,FOLLOW_LBRACE_in_synpred59_Java1767); if (state.failed) return ; |
| dbg.location(521,9); |
| // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )? |
| int alt171=2; |
| try { dbg.enterSubRule(171); |
| try { dbg.enterDecision(171, decisionCanBacktrack[171]); |
| |
| try { |
| isCyclicDecision = true; |
| alt171 = dfa171.predict(input); |
| } |
| catch (NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| throw nvae; |
| } |
| } finally {dbg.exitDecision(171);} |
| |
| switch (alt171) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation |
| { |
| dbg.location(521,10); |
| pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778); |
| explicitConstructorInvocation(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(171);} |
| |
| dbg.location(523,9); |
| // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )* |
| try { dbg.enterSubRule(172); |
| |
| loop172: |
| do { |
| int alt172=2; |
| try { dbg.enterDecision(172, decisionCanBacktrack[172]); |
| |
| int LA172_0 = input.LA(1); |
| |
| if ( ((LA172_0>=IDENTIFIER && LA172_0<=NULL)||(LA172_0>=ABSTRACT && LA172_0<=BYTE)||(LA172_0>=CHAR && LA172_0<=CLASS)||LA172_0==CONTINUE||(LA172_0>=DO && LA172_0<=DOUBLE)||LA172_0==ENUM||LA172_0==FINAL||(LA172_0>=FLOAT && LA172_0<=FOR)||LA172_0==IF||(LA172_0>=INT && LA172_0<=NEW)||(LA172_0>=PRIVATE && LA172_0<=THROW)||(LA172_0>=TRANSIENT && LA172_0<=LPAREN)||LA172_0==LBRACE||LA172_0==SEMI||(LA172_0>=BANG && LA172_0<=TILDE)||(LA172_0>=PLUSPLUS && LA172_0<=SUB)||LA172_0==MONKEYS_AT||LA172_0==LT) ) { |
| alt172=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(172);} |
| |
| switch (alt172) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:523:10: blockStatement |
| { |
| dbg.location(523,10); |
| pushFollow(FOLLOW_blockStatement_in_synpred59_Java1800); |
| blockStatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop172; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(172);} |
| |
| dbg.location(525,9); |
| match(input,RBRACE,FOLLOW_RBRACE_in_synpred59_Java1821); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred59_Java |
| |
| // $ANTLR start synpred68_Java |
| public final void synpred68_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:567:9: ( interfaceFieldDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration |
| { |
| dbg.location(567,9); |
| pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172); |
| interfaceFieldDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred68_Java |
| |
| // $ANTLR start synpred69_Java |
| public final void synpred69_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:568:9: ( interfaceMethodDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration |
| { |
| dbg.location(568,9); |
| pushFollow(FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182); |
| interfaceMethodDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred69_Java |
| |
| // $ANTLR start synpred70_Java |
| public final void synpred70_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:569:9: ( interfaceDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration |
| { |
| dbg.location(569,9); |
| pushFollow(FOLLOW_interfaceDeclaration_in_synpred70_Java2192); |
| interfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred70_Java |
| |
| // $ANTLR start synpred71_Java |
| public final void synpred71_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:570:9: ( classDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:570:9: classDeclaration |
| { |
| dbg.location(570,9); |
| pushFollow(FOLLOW_classDeclaration_in_synpred71_Java2202); |
| classDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred71_Java |
| |
| // $ANTLR start synpred96_Java |
| public final void synpred96_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:665:9: ( ellipsisParameterDecl ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl |
| { |
| dbg.location(665,9); |
| pushFollow(FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953); |
| ellipsisParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred96_Java |
| |
| // $ANTLR start synpred98_Java |
| public final void synpred98_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:666:9: ( normalParameterDecl ( ',' normalParameterDecl )* ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )* |
| { |
| dbg.location(666,9); |
| pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2963); |
| normalParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(667,9); |
| // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )* |
| try { dbg.enterSubRule(175); |
| |
| loop175: |
| do { |
| int alt175=2; |
| try { dbg.enterDecision(175, decisionCanBacktrack[175]); |
| |
| int LA175_0 = input.LA(1); |
| |
| if ( (LA175_0==COMMA) ) { |
| alt175=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(175);} |
| |
| switch (alt175) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl |
| { |
| dbg.location(667,10); |
| match(input,COMMA,FOLLOW_COMMA_in_synpred98_Java2974); if (state.failed) return ; |
| dbg.location(667,14); |
| pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2976); |
| normalParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop175; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(175);} |
| |
| |
| } |
| } |
| // $ANTLR end synpred98_Java |
| |
| // $ANTLR start synpred99_Java |
| public final void synpred99_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:669:10: ( normalParameterDecl ',' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ',' |
| { |
| dbg.location(669,10); |
| pushFollow(FOLLOW_normalParameterDecl_in_synpred99_Java2998); |
| normalParameterDecl(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(670,9); |
| match(input,COMMA,FOLLOW_COMMA_in_synpred99_Java3008); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred99_Java |
| |
| // $ANTLR start synpred103_Java |
| public final void synpred103_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:689:9: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' |
| { |
| dbg.location(689,9); |
| // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? |
| int alt176=2; |
| try { dbg.enterSubRule(176); |
| try { dbg.enterDecision(176, decisionCanBacktrack[176]); |
| |
| int LA176_0 = input.LA(1); |
| |
| if ( (LA176_0==LT) ) { |
| alt176=1; |
| } |
| } finally {dbg.exitDecision(176);} |
| |
| switch (alt176) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments |
| { |
| dbg.location(689,10); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(176);} |
| |
| dbg.location(691,9); |
| if ( input.LA(1)==SUPER||input.LA(1)==THIS ) { |
| input.consume(); |
| state.errorRecovery=false;state.failed=false; |
| } |
| else { |
| if (state.backtracking>0) {state.failed=true; return ;} |
| MismatchedSetException mse = new MismatchedSetException(null,input); |
| dbg.recognitionException(mse); |
| throw mse; |
| } |
| |
| dbg.location(694,9); |
| pushFollow(FOLLOW_arguments_in_synpred103_Java3197); |
| arguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(694,19); |
| match(input,SEMI,FOLLOW_SEMI_in_synpred103_Java3199); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred103_Java |
| |
| // $ANTLR start synpred117_Java |
| public final void synpred117_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:776:9: ( annotationMethodDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration |
| { |
| dbg.location(776,9); |
| pushFollow(FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781); |
| annotationMethodDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred117_Java |
| |
| // $ANTLR start synpred118_Java |
| public final void synpred118_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:777:9: ( interfaceFieldDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration |
| { |
| dbg.location(777,9); |
| pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791); |
| interfaceFieldDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred118_Java |
| |
| // $ANTLR start synpred119_Java |
| public final void synpred119_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:778:9: ( normalClassDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration |
| { |
| dbg.location(778,9); |
| pushFollow(FOLLOW_normalClassDeclaration_in_synpred119_Java3801); |
| normalClassDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred119_Java |
| |
| // $ANTLR start synpred120_Java |
| public final void synpred120_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:779:9: ( normalInterfaceDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration |
| { |
| dbg.location(779,9); |
| pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811); |
| normalInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred120_Java |
| |
| // $ANTLR start synpred121_Java |
| public final void synpred121_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:780:9: ( enumDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration |
| { |
| dbg.location(780,9); |
| pushFollow(FOLLOW_enumDeclaration_in_synpred121_Java3821); |
| enumDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred121_Java |
| |
| // $ANTLR start synpred122_Java |
| public final void synpred122_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:781:9: ( annotationTypeDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration |
| { |
| dbg.location(781,9); |
| pushFollow(FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831); |
| annotationTypeDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred122_Java |
| |
| // $ANTLR start synpred125_Java |
| public final void synpred125_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:824:9: ( localVariableDeclarationStatement ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement |
| { |
| dbg.location(824,9); |
| pushFollow(FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986); |
| localVariableDeclarationStatement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred125_Java |
| |
| // $ANTLR start synpred126_Java |
| public final void synpred126_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:825:9: ( classOrInterfaceDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration |
| { |
| dbg.location(825,9); |
| pushFollow(FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996); |
| classOrInterfaceDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred126_Java |
| |
| // $ANTLR start synpred130_Java |
| public final void synpred130_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:845:9: ( ( 'assert' ) expression ( ':' expression )? ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';' |
| { |
| dbg.location(845,9); |
| // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:845:10: 'assert' |
| { |
| dbg.location(845,10); |
| match(input,ASSERT,FOLLOW_ASSERT_in_synpred130_Java4122); if (state.failed) return ; |
| |
| } |
| |
| dbg.location(847,9); |
| pushFollow(FOLLOW_expression_in_synpred130_Java4142); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(847,20); |
| // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )? |
| int alt179=2; |
| try { dbg.enterSubRule(179); |
| try { dbg.enterDecision(179, decisionCanBacktrack[179]); |
| |
| int LA179_0 = input.LA(1); |
| |
| if ( (LA179_0==COLON) ) { |
| alt179=1; |
| } |
| } finally {dbg.exitDecision(179);} |
| |
| switch (alt179) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:847:21: ':' expression |
| { |
| dbg.location(847,21); |
| match(input,COLON,FOLLOW_COLON_in_synpred130_Java4145); if (state.failed) return ; |
| dbg.location(847,25); |
| pushFollow(FOLLOW_expression_in_synpred130_Java4147); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(179);} |
| |
| dbg.location(847,38); |
| match(input,SEMI,FOLLOW_SEMI_in_synpred130_Java4151); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred130_Java |
| |
| // $ANTLR start synpred132_Java |
| public final void synpred132_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:848:9: ( 'assert' expression ( ':' expression )? ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';' |
| { |
| dbg.location(848,9); |
| match(input,ASSERT,FOLLOW_ASSERT_in_synpred132_Java4161); if (state.failed) return ; |
| dbg.location(848,19); |
| pushFollow(FOLLOW_expression_in_synpred132_Java4164); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(848,30); |
| // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )? |
| int alt180=2; |
| try { dbg.enterSubRule(180); |
| try { dbg.enterDecision(180, decisionCanBacktrack[180]); |
| |
| int LA180_0 = input.LA(1); |
| |
| if ( (LA180_0==COLON) ) { |
| alt180=1; |
| } |
| } finally {dbg.exitDecision(180);} |
| |
| switch (alt180) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:848:31: ':' expression |
| { |
| dbg.location(848,31); |
| match(input,COLON,FOLLOW_COLON_in_synpred132_Java4167); if (state.failed) return ; |
| dbg.location(848,35); |
| pushFollow(FOLLOW_expression_in_synpred132_Java4169); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| break; |
| |
| } |
| } finally {dbg.exitSubRule(180);} |
| |
| dbg.location(848,48); |
| match(input,SEMI,FOLLOW_SEMI_in_synpred132_Java4173); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred132_Java |
| |
| // $ANTLR start synpred133_Java |
| public final void synpred133_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:849:39: ( 'else' statement ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:849:39: 'else' statement |
| { |
| dbg.location(849,39); |
| match(input,ELSE,FOLLOW_ELSE_in_synpred133_Java4190); if (state.failed) return ; |
| dbg.location(849,46); |
| pushFollow(FOLLOW_statement_in_synpred133_Java4192); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred133_Java |
| |
| // $ANTLR start synpred148_Java |
| public final void synpred148_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:864:9: ( expression ';' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:864:9: expression ';' |
| { |
| dbg.location(864,9); |
| pushFollow(FOLLOW_expression_in_synpred148_Java4404); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(864,21); |
| match(input,SEMI,FOLLOW_SEMI_in_synpred148_Java4407); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred148_Java |
| |
| // $ANTLR start synpred149_Java |
| public final void synpred149_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:865:9: ( IDENTIFIER ':' statement ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement |
| { |
| dbg.location(865,9); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred149_Java4417); if (state.failed) return ; |
| dbg.location(865,20); |
| match(input,COLON,FOLLOW_COLON_in_synpred149_Java4419); if (state.failed) return ; |
| dbg.location(865,24); |
| pushFollow(FOLLOW_statement_in_synpred149_Java4421); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred149_Java |
| |
| // $ANTLR start synpred153_Java |
| public final void synpred153_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:889:13: ( catches 'finally' block ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block |
| { |
| dbg.location(889,13); |
| pushFollow(FOLLOW_catches_in_synpred153_Java4573); |
| catches(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(889,21); |
| match(input,FINALLY,FOLLOW_FINALLY_in_synpred153_Java4575); if (state.failed) return ; |
| dbg.location(889,31); |
| pushFollow(FOLLOW_block_in_synpred153_Java4577); |
| block(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred153_Java |
| |
| // $ANTLR start synpred154_Java |
| public final void synpred154_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:890:13: ( catches ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:890:13: catches |
| { |
| dbg.location(890,13); |
| pushFollow(FOLLOW_catches_in_synpred154_Java4591); |
| catches(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred154_Java |
| |
| // $ANTLR start synpred157_Java |
| public final void synpred157_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:915:9: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement |
| { |
| dbg.location(915,9); |
| match(input,FOR,FOLLOW_FOR_in_synpred157_Java4775); if (state.failed) return ; |
| dbg.location(915,15); |
| match(input,LPAREN,FOLLOW_LPAREN_in_synpred157_Java4777); if (state.failed) return ; |
| dbg.location(915,19); |
| pushFollow(FOLLOW_variableModifiers_in_synpred157_Java4779); |
| variableModifiers(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(915,37); |
| pushFollow(FOLLOW_type_in_synpred157_Java4781); |
| type(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(915,42); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred157_Java4783); if (state.failed) return ; |
| dbg.location(915,53); |
| match(input,COLON,FOLLOW_COLON_in_synpred157_Java4785); if (state.failed) return ; |
| dbg.location(916,9); |
| pushFollow(FOLLOW_expression_in_synpred157_Java4795); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(916,20); |
| match(input,RPAREN,FOLLOW_RPAREN_in_synpred157_Java4797); if (state.failed) return ; |
| dbg.location(916,24); |
| pushFollow(FOLLOW_statement_in_synpred157_Java4799); |
| statement(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred157_Java |
| |
| // $ANTLR start synpred161_Java |
| public final void synpred161_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:929:9: ( localVariableDeclaration ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration |
| { |
| dbg.location(929,9); |
| pushFollow(FOLLOW_localVariableDeclaration_in_synpred161_Java4962); |
| localVariableDeclaration(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred161_Java |
| |
| // $ANTLR start synpred202_Java |
| public final void synpred202_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1083:9: ( castExpression ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1083:9: castExpression |
| { |
| dbg.location(1083,9); |
| pushFollow(FOLLOW_castExpression_in_synpred202_Java6178); |
| castExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred202_Java |
| |
| // $ANTLR start synpred206_Java |
| public final void synpred206_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1093:9: ( '(' primitiveType ')' unaryExpression ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression |
| { |
| dbg.location(1093,9); |
| match(input,LPAREN,FOLLOW_LPAREN_in_synpred206_Java6268); if (state.failed) return ; |
| dbg.location(1093,13); |
| pushFollow(FOLLOW_primitiveType_in_synpred206_Java6270); |
| primitiveType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1093,27); |
| match(input,RPAREN,FOLLOW_RPAREN_in_synpred206_Java6272); if (state.failed) return ; |
| dbg.location(1093,31); |
| pushFollow(FOLLOW_unaryExpression_in_synpred206_Java6274); |
| unaryExpression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred206_Java |
| |
| // $ANTLR start synpred208_Java |
| public final void synpred208_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1103:10: ( '.' IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER |
| { |
| dbg.location(1103,10); |
| match(input,DOT,FOLLOW_DOT_in_synpred208_Java6332); if (state.failed) return ; |
| dbg.location(1103,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred208_Java6334); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred208_Java |
| |
| // $ANTLR start synpred209_Java |
| public final void synpred209_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1105:10: ( identifierSuffix ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix |
| { |
| dbg.location(1105,10); |
| pushFollow(FOLLOW_identifierSuffix_in_synpred209_Java6356); |
| identifierSuffix(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred209_Java |
| |
| // $ANTLR start synpred211_Java |
| public final void synpred211_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1108:10: ( '.' IDENTIFIER ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER |
| { |
| dbg.location(1108,10); |
| match(input,DOT,FOLLOW_DOT_in_synpred211_Java6388); if (state.failed) return ; |
| dbg.location(1108,14); |
| match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred211_Java6390); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred211_Java |
| |
| // $ANTLR start synpred212_Java |
| public final void synpred212_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1110:10: ( identifierSuffix ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix |
| { |
| dbg.location(1110,10); |
| pushFollow(FOLLOW_identifierSuffix_in_synpred212_Java6412); |
| identifierSuffix(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred212_Java |
| |
| // $ANTLR start synpred224_Java |
| public final void synpred224_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1138:10: ( '[' expression ']' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']' |
| { |
| dbg.location(1138,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred224_Java6656); if (state.failed) return ; |
| dbg.location(1138,14); |
| pushFollow(FOLLOW_expression_in_synpred224_Java6658); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1138,25); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred224_Java6660); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred224_Java |
| |
| // $ANTLR start synpred236_Java |
| public final void synpred236_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1161:9: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest |
| { |
| dbg.location(1161,9); |
| match(input,NEW,FOLLOW_NEW_in_synpred236_Java6866); if (state.failed) return ; |
| dbg.location(1161,15); |
| pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868); |
| nonWildcardTypeArguments(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1161,40); |
| pushFollow(FOLLOW_classOrInterfaceType_in_synpred236_Java6870); |
| classOrInterfaceType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1161,61); |
| pushFollow(FOLLOW_classCreatorRest_in_synpred236_Java6872); |
| classCreatorRest(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred236_Java |
| |
| // $ANTLR start synpred237_Java |
| public final void synpred237_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1162:9: ( 'new' classOrInterfaceType classCreatorRest ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest |
| { |
| dbg.location(1162,9); |
| match(input,NEW,FOLLOW_NEW_in_synpred237_Java6882); if (state.failed) return ; |
| dbg.location(1162,15); |
| pushFollow(FOLLOW_classOrInterfaceType_in_synpred237_Java6884); |
| classOrInterfaceType(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1162,36); |
| pushFollow(FOLLOW_classCreatorRest_in_synpred237_Java6886); |
| classCreatorRest(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred237_Java |
| |
| // $ANTLR start synpred239_Java |
| public final void synpred239_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1167:9: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer |
| { |
| dbg.location(1167,9); |
| match(input,NEW,FOLLOW_NEW_in_synpred239_Java6915); if (state.failed) return ; |
| dbg.location(1167,15); |
| pushFollow(FOLLOW_createdName_in_synpred239_Java6917); |
| createdName(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1168,9); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6927); if (state.failed) return ; |
| dbg.location(1168,13); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6929); if (state.failed) return ; |
| dbg.location(1169,9); |
| // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )* |
| try { dbg.enterSubRule(193); |
| |
| loop193: |
| do { |
| int alt193=2; |
| try { dbg.enterDecision(193, decisionCanBacktrack[193]); |
| |
| int LA193_0 = input.LA(1); |
| |
| if ( (LA193_0==LBRACKET) ) { |
| alt193=1; |
| } |
| |
| |
| } finally {dbg.exitDecision(193);} |
| |
| switch (alt193) { |
| case 1 : |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1169:10: '[' ']' |
| { |
| dbg.location(1169,10); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6940); if (state.failed) return ; |
| dbg.location(1169,14); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6942); if (state.failed) return ; |
| |
| } |
| break; |
| |
| default : |
| break loop193; |
| } |
| } while (true); |
| } finally {dbg.exitSubRule(193);} |
| |
| dbg.location(1171,9); |
| pushFollow(FOLLOW_arrayInitializer_in_synpred239_Java6963); |
| arrayInitializer(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred239_Java |
| |
| // $ANTLR start synpred240_Java |
| public final void synpred240_Java_fragment() throws RecognitionException { |
| // src/com/google/doclava/parser/Java.g:1176:13: ( '[' expression ']' ) |
| dbg.enterAlt(1); |
| |
| // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']' |
| { |
| dbg.location(1176,13); |
| match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred240_Java7012); if (state.failed) return ; |
| dbg.location(1176,17); |
| pushFollow(FOLLOW_expression_in_synpred240_Java7014); |
| expression(); |
| |
| state._fsp--; |
| if (state.failed) return ; |
| dbg.location(1177,13); |
| match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred240_Java7028); if (state.failed) return ; |
| |
| } |
| } |
| // $ANTLR end synpred240_Java |
| |
| // Delegated rules |
| |
| public final boolean synpred43_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred43_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred98_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred98_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred157_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred157_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred224_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred224_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred211_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred211_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred121_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred121_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred239_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred239_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred69_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred69_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred202_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred202_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred154_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred154_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred71_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred71_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred133_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred133_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred125_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred125_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred132_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred132_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred119_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred119_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred54_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred54_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred148_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred148_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred117_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred117_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred2_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred2_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred130_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred130_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred126_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred126_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred59_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred59_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred212_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred212_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred161_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred161_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred57_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred57_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred209_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred209_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred68_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred68_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred53_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred53_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred52_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred52_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred236_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred236_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred12_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred12_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred149_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred149_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred120_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred120_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred122_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred122_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred240_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred240_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred206_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred206_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred70_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred70_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred27_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred27_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred96_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred96_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred153_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred153_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred99_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred99_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred103_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred103_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred237_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred237_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred118_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred118_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| public final boolean synpred208_Java() { |
| state.backtracking++; |
| dbg.beginBacktrack(state.backtracking); |
| int start = input.mark(); |
| try { |
| synpred208_Java_fragment(); // can never throw exception |
| } catch (RecognitionException re) { |
| System.err.println("impossible: "+re); |
| } |
| boolean success = !state.failed; |
| input.rewind(start); |
| dbg.endBacktrack(state.backtracking, success); |
| state.backtracking--; |
| state.failed=false; |
| return success; |
| } |
| |
| |
| protected DFA2 dfa2 = new DFA2(this); |
| protected DFA12 dfa12 = new DFA12(this); |
| protected DFA13 dfa13 = new DFA13(this); |
| protected DFA15 dfa15 = new DFA15(this); |
| protected DFA31 dfa31 = new DFA31(this); |
| protected DFA39 dfa39 = new DFA39(this); |
| protected DFA49 dfa49 = new DFA49(this); |
| protected DFA42 dfa42 = new DFA42(this); |
| protected DFA53 dfa53 = new DFA53(this); |
| protected DFA76 dfa76 = new DFA76(this); |
| protected DFA87 dfa87 = new DFA87(this); |
| protected DFA90 dfa90 = new DFA90(this); |
| protected DFA98 dfa98 = new DFA98(this); |
| protected DFA109 dfa109 = new DFA109(this); |
| protected DFA112 dfa112 = new DFA112(this); |
| protected DFA130 dfa130 = new DFA130(this); |
| protected DFA133 dfa133 = new DFA133(this); |
| protected DFA135 dfa135 = new DFA135(this); |
| protected DFA143 dfa143 = new DFA143(this); |
| protected DFA142 dfa142 = new DFA142(this); |
| protected DFA148 dfa148 = new DFA148(this); |
| protected DFA171 dfa171 = new DFA171(this); |
| static final String DFA2_eotS = |
| "\24\uffff"; |
| static final String DFA2_eofS = |
| "\1\3\23\uffff"; |
| static final String DFA2_minS = |
| "\1\34\1\0\22\uffff"; |
| static final String DFA2_maxS = |
| "\1\162\1\0\22\uffff"; |
| static final String DFA2_acceptS = |
| "\2\uffff\1\1\1\2\20\uffff"; |
| static final String DFA2_specialS = |
| "\1\uffff\1\0\22\uffff}>"; |
| static final String[] DFA2_transitionS = { |
| "\1\3\7\uffff\1\3\6\uffff\1\3\1\uffff\1\3\6\uffff\1\3\2\uffff"+ |
| "\1\3\1\uffff\1\3\1\uffff\1\2\3\3\2\uffff\2\3\2\uffff\1\3\3\uffff"+ |
| "\1\3\2\uffff\1\3\7\uffff\1\3\35\uffff\1\1", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS); |
| static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS); |
| static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS); |
| static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS); |
| static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS); |
| static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS); |
| static final short[][] DFA2_transition; |
| |
| static { |
| int numStates = DFA2_transitionS.length; |
| DFA2_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]); |
| } |
| } |
| |
| class DFA2 extends DFA { |
| |
| public DFA2(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 2; |
| this.eot = DFA2_eot; |
| this.eof = DFA2_eof; |
| this.min = DFA2_min; |
| this.max = DFA2_max; |
| this.accept = DFA2_accept; |
| this.special = DFA2_special; |
| this.transition = DFA2_transition; |
| } |
| public String getDescription() { |
| return "298:9: ( ( annotations )? packageDeclaration )?"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA2_1 = input.LA(1); |
| |
| |
| int index2_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred2_Java()) ) {s = 2;} |
| |
| else if ( (true) ) {s = 3;} |
| |
| |
| input.seek(index2_1); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 2, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA12_eotS = |
| "\20\uffff"; |
| static final String DFA12_eofS = |
| "\20\uffff"; |
| static final String DFA12_minS = |
| "\1\34\14\0\3\uffff"; |
| static final String DFA12_maxS = |
| "\1\162\14\0\3\uffff"; |
| static final String DFA12_acceptS = |
| "\15\uffff\1\1\1\uffff\1\2"; |
| static final String DFA12_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\3\uffff}>"; |
| static final String[] DFA12_transitionS = { |
| "\1\6\7\uffff\1\15\6\uffff\1\15\1\uffff\1\7\11\uffff\1\17\1\uffff"+ |
| "\1\10\2\uffff\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff"+ |
| "\1\12\2\uffff\1\13\45\uffff\1\1", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); |
| static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); |
| static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); |
| static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); |
| static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); |
| static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); |
| static final short[][] DFA12_transition; |
| |
| static { |
| int numStates = DFA12_transitionS.length; |
| DFA12_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); |
| } |
| } |
| |
| class DFA12 extends DFA { |
| |
| public DFA12(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 12; |
| this.eot = DFA12_eot; |
| this.eof = DFA12_eof; |
| this.min = DFA12_min; |
| this.max = DFA12_max; |
| this.accept = DFA12_accept; |
| this.special = DFA12_special; |
| this.transition = DFA12_transition; |
| } |
| public String getDescription() { |
| return "341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA12_1 = input.LA(1); |
| |
| |
| int index12_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA12_2 = input.LA(1); |
| |
| |
| int index12_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA12_3 = input.LA(1); |
| |
| |
| int index12_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA12_4 = input.LA(1); |
| |
| |
| int index12_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA12_5 = input.LA(1); |
| |
| |
| int index12_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA12_6 = input.LA(1); |
| |
| |
| int index12_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA12_7 = input.LA(1); |
| |
| |
| int index12_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA12_8 = input.LA(1); |
| |
| |
| int index12_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA12_9 = input.LA(1); |
| |
| |
| int index12_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA12_10 = input.LA(1); |
| |
| |
| int index12_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA12_11 = input.LA(1); |
| |
| |
| int index12_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA12_12 = input.LA(1); |
| |
| |
| int index12_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred12_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index12_12); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 12, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA13_eotS = |
| "\17\uffff"; |
| static final String DFA13_eofS = |
| "\17\uffff"; |
| static final String DFA13_minS = |
| "\1\4\1\uffff\1\4\14\uffff"; |
| static final String DFA13_maxS = |
| "\1\165\1\uffff\1\67\14\uffff"; |
| static final String DFA13_acceptS = |
| "\1\uffff\1\15\1\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13"+ |
| "\1\14\1\1"; |
| static final String DFA13_specialS = |
| "\17\uffff}>"; |
| static final String[] DFA13_transitionS = { |
| "\1\1\27\uffff\1\7\1\uffff\1\1\1\uffff\1\1\2\uffff\2\1\4\uffff"+ |
| "\1\1\1\uffff\1\1\1\uffff\1\10\1\uffff\1\1\6\uffff\3\1\1\11\2"+ |
| "\uffff\1\5\1\4\1\3\1\uffff\1\1\1\6\1\15\2\uffff\1\12\3\uffff"+ |
| "\1\13\1\uffff\1\1\1\14\45\uffff\1\2\2\uffff\1\1", |
| "", |
| "\1\16\62\uffff\1\1", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS); |
| static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS); |
| static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS); |
| static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS); |
| static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS); |
| static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS); |
| static final short[][] DFA13_transition; |
| |
| static { |
| int numStates = DFA13_transitionS.length; |
| DFA13_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]); |
| } |
| } |
| |
| class DFA13 extends DFA { |
| |
| public DFA13(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 13; |
| this.eot = DFA13_eot; |
| this.eof = DFA13_eof; |
| this.min = DFA13_min; |
| this.max = DFA13_max; |
| this.accept = DFA13_accept; |
| this.special = DFA13_special; |
| this.transition = DFA13_transition; |
| } |
| public String getDescription() { |
| return "()* loopback of 349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| } |
| static final String DFA15_eotS = |
| "\17\uffff"; |
| static final String DFA15_eofS = |
| "\17\uffff"; |
| static final String DFA15_minS = |
| "\1\34\14\0\2\uffff"; |
| static final String DFA15_maxS = |
| "\1\162\14\0\2\uffff"; |
| static final String DFA15_acceptS = |
| "\15\uffff\1\1\1\2"; |
| static final String DFA15_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\2\uffff}>"; |
| static final String[] DFA15_transitionS = { |
| "\1\6\7\uffff\1\15\6\uffff\1\16\1\uffff\1\7\13\uffff\1\10\2\uffff"+ |
| "\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff"+ |
| "\1\13\45\uffff\1\1", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS); |
| static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS); |
| static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS); |
| static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS); |
| static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS); |
| static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS); |
| static final short[][] DFA15_transition; |
| |
| static { |
| int numStates = DFA15_transitionS.length; |
| DFA15_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA15_transition[i] = DFA.unpackEncodedString(DFA15_transitionS[i]); |
| } |
| } |
| |
| class DFA15 extends DFA { |
| |
| public DFA15(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 15; |
| this.eot = DFA15_eot; |
| this.eof = DFA15_eof; |
| this.min = DFA15_min; |
| this.max = DFA15_max; |
| this.accept = DFA15_accept; |
| this.special = DFA15_special; |
| this.transition = DFA15_transition; |
| } |
| public String getDescription() { |
| return "372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA15_1 = input.LA(1); |
| |
| |
| int index15_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA15_2 = input.LA(1); |
| |
| |
| int index15_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA15_3 = input.LA(1); |
| |
| |
| int index15_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA15_4 = input.LA(1); |
| |
| |
| int index15_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA15_5 = input.LA(1); |
| |
| |
| int index15_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA15_6 = input.LA(1); |
| |
| |
| int index15_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA15_7 = input.LA(1); |
| |
| |
| int index15_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA15_8 = input.LA(1); |
| |
| |
| int index15_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA15_9 = input.LA(1); |
| |
| |
| int index15_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA15_10 = input.LA(1); |
| |
| |
| int index15_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA15_11 = input.LA(1); |
| |
| |
| int index15_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA15_12 = input.LA(1); |
| |
| |
| int index15_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred27_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index15_12); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 15, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA31_eotS = |
| "\17\uffff"; |
| static final String DFA31_eofS = |
| "\17\uffff"; |
| static final String DFA31_minS = |
| "\1\34\14\0\2\uffff"; |
| static final String DFA31_maxS = |
| "\1\162\14\0\2\uffff"; |
| static final String DFA31_acceptS = |
| "\15\uffff\1\1\1\2"; |
| static final String DFA31_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\2\uffff}>"; |
| static final String[] DFA31_transitionS = { |
| "\1\6\20\uffff\1\7\11\uffff\1\15\1\uffff\1\10\2\uffff\1\4\1\3"+ |
| "\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13"+ |
| "\45\uffff\1\1", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS); |
| static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS); |
| static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS); |
| static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS); |
| static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS); |
| static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS); |
| static final short[][] DFA31_transition; |
| |
| static { |
| int numStates = DFA31_transitionS.length; |
| DFA31_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA31_transition[i] = DFA.unpackEncodedString(DFA31_transitionS[i]); |
| } |
| } |
| |
| class DFA31 extends DFA { |
| |
| public DFA31(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 31; |
| this.eot = DFA31_eot; |
| this.eof = DFA31_eof; |
| this.min = DFA31_min; |
| this.max = DFA31_max; |
| this.accept = DFA31_accept; |
| this.special = DFA31_special; |
| this.transition = DFA31_transition; |
| } |
| public String getDescription() { |
| return "460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA31_1 = input.LA(1); |
| |
| |
| int index31_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA31_2 = input.LA(1); |
| |
| |
| int index31_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA31_3 = input.LA(1); |
| |
| |
| int index31_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA31_4 = input.LA(1); |
| |
| |
| int index31_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA31_5 = input.LA(1); |
| |
| |
| int index31_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA31_6 = input.LA(1); |
| |
| |
| int index31_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA31_7 = input.LA(1); |
| |
| |
| int index31_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA31_8 = input.LA(1); |
| |
| |
| int index31_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA31_9 = input.LA(1); |
| |
| |
| int index31_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA31_10 = input.LA(1); |
| |
| |
| int index31_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA31_11 = input.LA(1); |
| |
| |
| int index31_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA31_12 = input.LA(1); |
| |
| |
| int index31_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred43_Java()) ) {s = 13;} |
| |
| else if ( (true) ) {s = 14;} |
| |
| |
| input.seek(index31_12); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 31, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA39_eotS = |
| "\25\uffff"; |
| static final String DFA39_eofS = |
| "\25\uffff"; |
| static final String DFA39_minS = |
| "\1\4\16\0\6\uffff"; |
| static final String DFA39_maxS = |
| "\1\165\16\0\6\uffff"; |
| static final String DFA39_acceptS = |
| "\17\uffff\1\2\1\uffff\1\3\1\uffff\1\4\1\1"; |
| static final String DFA39_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+ |
| "\1\15\6\uffff}>"; |
| static final String[] DFA39_transitionS = { |
| "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+ |
| "\21\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+ |
| "\1\16\1\23\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+ |
| "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1"+ |
| "\2\uffff\1\17", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA39_eot = DFA.unpackEncodedString(DFA39_eotS); |
| static final short[] DFA39_eof = DFA.unpackEncodedString(DFA39_eofS); |
| static final char[] DFA39_min = DFA.unpackEncodedStringToUnsignedChars(DFA39_minS); |
| static final char[] DFA39_max = DFA.unpackEncodedStringToUnsignedChars(DFA39_maxS); |
| static final short[] DFA39_accept = DFA.unpackEncodedString(DFA39_acceptS); |
| static final short[] DFA39_special = DFA.unpackEncodedString(DFA39_specialS); |
| static final short[][] DFA39_transition; |
| |
| static { |
| int numStates = DFA39_transitionS.length; |
| DFA39_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA39_transition[i] = DFA.unpackEncodedString(DFA39_transitionS[i]); |
| } |
| } |
| |
| class DFA39 extends DFA { |
| |
| public DFA39(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 39; |
| this.eot = DFA39_eot; |
| this.eof = DFA39_eof; |
| this.min = DFA39_min; |
| this.max = DFA39_max; |
| this.accept = DFA39_accept; |
| this.special = DFA39_special; |
| this.transition = DFA39_transition; |
| } |
| public String getDescription() { |
| return "502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA39_1 = input.LA(1); |
| |
| |
| int index39_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA39_2 = input.LA(1); |
| |
| |
| int index39_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA39_3 = input.LA(1); |
| |
| |
| int index39_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA39_4 = input.LA(1); |
| |
| |
| int index39_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA39_5 = input.LA(1); |
| |
| |
| int index39_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA39_6 = input.LA(1); |
| |
| |
| int index39_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA39_7 = input.LA(1); |
| |
| |
| int index39_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA39_8 = input.LA(1); |
| |
| |
| int index39_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA39_9 = input.LA(1); |
| |
| |
| int index39_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA39_10 = input.LA(1); |
| |
| |
| int index39_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA39_11 = input.LA(1); |
| |
| |
| int index39_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA39_12 = input.LA(1); |
| |
| |
| int index39_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| else if ( (synpred54_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 19;} |
| |
| |
| input.seek(index39_12); |
| if ( s>=0 ) return s; |
| break; |
| case 12 : |
| int LA39_13 = input.LA(1); |
| |
| |
| int index39_13 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| |
| input.seek(index39_13); |
| if ( s>=0 ) return s; |
| break; |
| case 13 : |
| int LA39_14 = input.LA(1); |
| |
| |
| int index39_14 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred52_Java()) ) {s = 20;} |
| |
| else if ( (synpred53_Java()) ) {s = 15;} |
| |
| |
| input.seek(index39_14); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 39, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA49_eotS = |
| "\22\uffff"; |
| static final String DFA49_eofS = |
| "\22\uffff"; |
| static final String DFA49_minS = |
| "\1\4\16\0\3\uffff"; |
| static final String DFA49_maxS = |
| "\1\165\16\0\3\uffff"; |
| static final String DFA49_acceptS = |
| "\17\uffff\1\2\1\uffff\1\1"; |
| static final String DFA49_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+ |
| "\1\15\3\uffff}>"; |
| static final String[] DFA49_transitionS = { |
| "\1\16\27\uffff\1\6\1\uffff\1\17\1\uffff\1\17\2\uffff\1\17\5"+ |
| "\uffff\1\17\3\uffff\1\7\1\uffff\1\17\6\uffff\1\17\1\uffff\1"+ |
| "\17\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\17\1\5\1\14\2\uffff\1"+ |
| "\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1\2\uffff\1\15", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA49_eot = DFA.unpackEncodedString(DFA49_eotS); |
| static final short[] DFA49_eof = DFA.unpackEncodedString(DFA49_eofS); |
| static final char[] DFA49_min = DFA.unpackEncodedStringToUnsignedChars(DFA49_minS); |
| static final char[] DFA49_max = DFA.unpackEncodedStringToUnsignedChars(DFA49_maxS); |
| static final short[] DFA49_accept = DFA.unpackEncodedString(DFA49_acceptS); |
| static final short[] DFA49_special = DFA.unpackEncodedString(DFA49_specialS); |
| static final short[][] DFA49_transition; |
| |
| static { |
| int numStates = DFA49_transitionS.length; |
| DFA49_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA49_transition[i] = DFA.unpackEncodedString(DFA49_transitionS[i]); |
| } |
| } |
| |
| class DFA49 extends DFA { |
| |
| public DFA49(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 49; |
| this.eot = DFA49_eot; |
| this.eof = DFA49_eof; |
| this.min = DFA49_min; |
| this.max = DFA49_max; |
| this.accept = DFA49_accept; |
| this.special = DFA49_special; |
| this.transition = DFA49_transition; |
| } |
| public String getDescription() { |
| return "510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA49_1 = input.LA(1); |
| |
| |
| int index49_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA49_2 = input.LA(1); |
| |
| |
| int index49_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA49_3 = input.LA(1); |
| |
| |
| int index49_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA49_4 = input.LA(1); |
| |
| |
| int index49_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA49_5 = input.LA(1); |
| |
| |
| int index49_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA49_6 = input.LA(1); |
| |
| |
| int index49_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA49_7 = input.LA(1); |
| |
| |
| int index49_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA49_8 = input.LA(1); |
| |
| |
| int index49_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA49_9 = input.LA(1); |
| |
| |
| int index49_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA49_10 = input.LA(1); |
| |
| |
| int index49_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA49_11 = input.LA(1); |
| |
| |
| int index49_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA49_12 = input.LA(1); |
| |
| |
| int index49_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_12); |
| if ( s>=0 ) return s; |
| break; |
| case 12 : |
| int LA49_13 = input.LA(1); |
| |
| |
| int index49_13 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_13); |
| if ( s>=0 ) return s; |
| break; |
| case 13 : |
| int LA49_14 = input.LA(1); |
| |
| |
| int index49_14 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred59_Java()) ) {s = 17;} |
| |
| else if ( (true) ) {s = 15;} |
| |
| |
| input.seek(index49_14); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 49, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA42_eotS = |
| "\55\uffff"; |
| static final String DFA42_eofS = |
| "\55\uffff"; |
| static final String DFA42_minS = |
| "\1\4\1\uffff\10\0\43\uffff"; |
| static final String DFA42_maxS = |
| "\1\165\1\uffff\10\0\43\uffff"; |
| static final String DFA42_acceptS = |
| "\1\uffff\1\1\10\uffff\1\2\42\uffff"; |
| static final String DFA42_specialS = |
| "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>"; |
| static final String[] DFA42_transitionS = { |
| "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+ |
| "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+ |
| "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+ |
| "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+ |
| "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+ |
| "\1\12\2\uffff\1\1", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA42_eot = DFA.unpackEncodedString(DFA42_eotS); |
| static final short[] DFA42_eof = DFA.unpackEncodedString(DFA42_eofS); |
| static final char[] DFA42_min = DFA.unpackEncodedStringToUnsignedChars(DFA42_minS); |
| static final char[] DFA42_max = DFA.unpackEncodedStringToUnsignedChars(DFA42_maxS); |
| static final short[] DFA42_accept = DFA.unpackEncodedString(DFA42_acceptS); |
| static final short[] DFA42_special = DFA.unpackEncodedString(DFA42_specialS); |
| static final short[][] DFA42_transition; |
| |
| static { |
| int numStates = DFA42_transitionS.length; |
| DFA42_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA42_transition[i] = DFA.unpackEncodedString(DFA42_transitionS[i]); |
| } |
| } |
| |
| class DFA42 extends DFA { |
| |
| public DFA42(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 42; |
| this.eot = DFA42_eot; |
| this.eof = DFA42_eof; |
| this.min = DFA42_min; |
| this.max = DFA42_max; |
| this.accept = DFA42_accept; |
| this.special = DFA42_special; |
| this.transition = DFA42_transition; |
| } |
| public String getDescription() { |
| return "521:9: ( explicitConstructorInvocation )?"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA42_2 = input.LA(1); |
| |
| |
| int index42_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_2); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA42_3 = input.LA(1); |
| |
| |
| int index42_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_3); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA42_4 = input.LA(1); |
| |
| |
| int index42_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_4); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA42_5 = input.LA(1); |
| |
| |
| int index42_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_5); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA42_6 = input.LA(1); |
| |
| |
| int index42_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_6); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA42_7 = input.LA(1); |
| |
| |
| int index42_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_7); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA42_8 = input.LA(1); |
| |
| |
| int index42_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_8); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA42_9 = input.LA(1); |
| |
| |
| int index42_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index42_9); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 42, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA53_eotS = |
| "\26\uffff"; |
| static final String DFA53_eofS = |
| "\26\uffff"; |
| static final String DFA53_minS = |
| "\1\4\16\0\7\uffff"; |
| static final String DFA53_maxS = |
| "\1\165\16\0\7\uffff"; |
| static final String DFA53_acceptS = |
| "\17\uffff\1\2\1\uffff\1\3\1\4\1\uffff\1\5\1\1"; |
| static final String DFA53_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+ |
| "\1\15\7\uffff}>"; |
| static final String[] DFA53_transitionS = { |
| "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+ |
| "\22\4\uffff\1\16\1\uffff\1\22\1\uffff\1\7\1\uffff\1\16\6\uffff"+ |
| "\1\16\1\21\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+ |
| "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\7\uffff\1\24"+ |
| "\35\uffff\1\1\2\uffff\1\17", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS); |
| static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS); |
| static final char[] DFA53_min = DFA.unpackEncodedStringToUnsignedChars(DFA53_minS); |
| static final char[] DFA53_max = DFA.unpackEncodedStringToUnsignedChars(DFA53_maxS); |
| static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS); |
| static final short[] DFA53_special = DFA.unpackEncodedString(DFA53_specialS); |
| static final short[][] DFA53_transition; |
| |
| static { |
| int numStates = DFA53_transitionS.length; |
| DFA53_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA53_transition[i] = DFA.unpackEncodedString(DFA53_transitionS[i]); |
| } |
| } |
| |
| class DFA53 extends DFA { |
| |
| public DFA53(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 53; |
| this.eot = DFA53_eot; |
| this.eof = DFA53_eof; |
| this.min = DFA53_min; |
| this.max = DFA53_max; |
| this.accept = DFA53_accept; |
| this.special = DFA53_special; |
| this.transition = DFA53_transition; |
| } |
| public String getDescription() { |
| return "562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA53_1 = input.LA(1); |
| |
| |
| int index53_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA53_2 = input.LA(1); |
| |
| |
| int index53_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA53_3 = input.LA(1); |
| |
| |
| int index53_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA53_4 = input.LA(1); |
| |
| |
| int index53_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA53_5 = input.LA(1); |
| |
| |
| int index53_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA53_6 = input.LA(1); |
| |
| |
| int index53_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA53_7 = input.LA(1); |
| |
| |
| int index53_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA53_8 = input.LA(1); |
| |
| |
| int index53_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA53_9 = input.LA(1); |
| |
| |
| int index53_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA53_10 = input.LA(1); |
| |
| |
| int index53_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA53_11 = input.LA(1); |
| |
| |
| int index53_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA53_12 = input.LA(1); |
| |
| |
| int index53_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| else if ( (synpred70_Java()) ) {s = 17;} |
| |
| else if ( (synpred71_Java()) ) {s = 18;} |
| |
| |
| input.seek(index53_12); |
| if ( s>=0 ) return s; |
| break; |
| case 12 : |
| int LA53_13 = input.LA(1); |
| |
| |
| int index53_13 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| |
| input.seek(index53_13); |
| if ( s>=0 ) return s; |
| break; |
| case 13 : |
| int LA53_14 = input.LA(1); |
| |
| |
| int index53_14 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred68_Java()) ) {s = 21;} |
| |
| else if ( (synpred69_Java()) ) {s = 15;} |
| |
| |
| input.seek(index53_14); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 53, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA76_eotS = |
| "\12\uffff"; |
| static final String DFA76_eofS = |
| "\12\uffff"; |
| static final String DFA76_minS = |
| "\1\4\1\uffff\1\0\1\uffff\1\0\5\uffff"; |
| static final String DFA76_maxS = |
| "\1\165\1\uffff\1\0\1\uffff\1\0\5\uffff"; |
| static final String DFA76_acceptS = |
| "\1\uffff\1\1\1\uffff\1\2\6\uffff"; |
| static final String DFA76_specialS = |
| "\2\uffff\1\0\1\uffff\1\1\5\uffff}>"; |
| static final String[] DFA76_transitionS = { |
| "\12\3\20\uffff\1\3\1\uffff\1\3\2\uffff\1\3\5\uffff\1\3\5\uffff"+ |
| "\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\5\uffff\1\3\2\uffff"+ |
| "\1\4\2\uffff\1\2\4\uffff\1\3\2\uffff\1\3\46\uffff\1\1", |
| "", |
| "\1\uffff", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA76_eot = DFA.unpackEncodedString(DFA76_eotS); |
| static final short[] DFA76_eof = DFA.unpackEncodedString(DFA76_eofS); |
| static final char[] DFA76_min = DFA.unpackEncodedStringToUnsignedChars(DFA76_minS); |
| static final char[] DFA76_max = DFA.unpackEncodedStringToUnsignedChars(DFA76_maxS); |
| static final short[] DFA76_accept = DFA.unpackEncodedString(DFA76_acceptS); |
| static final short[] DFA76_special = DFA.unpackEncodedString(DFA76_specialS); |
| static final short[][] DFA76_transition; |
| |
| static { |
| int numStates = DFA76_transitionS.length; |
| DFA76_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA76_transition[i] = DFA.unpackEncodedString(DFA76_transitionS[i]); |
| } |
| } |
| |
| class DFA76 extends DFA { |
| |
| public DFA76(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 76; |
| this.eot = DFA76_eot; |
| this.eof = DFA76_eof; |
| this.min = DFA76_min; |
| this.max = DFA76_max; |
| this.accept = DFA76_accept; |
| this.special = DFA76_special; |
| this.transition = DFA76_transition; |
| } |
| public String getDescription() { |
| return "688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA76_2 = input.LA(1); |
| |
| |
| int index76_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred103_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 3;} |
| |
| |
| input.seek(index76_2); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA76_4 = input.LA(1); |
| |
| |
| int index76_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred103_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 3;} |
| |
| |
| input.seek(index76_4); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 76, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA87_eotS = |
| "\26\uffff"; |
| static final String DFA87_eofS = |
| "\26\uffff"; |
| static final String DFA87_minS = |
| "\1\4\16\0\7\uffff"; |
| static final String DFA87_maxS = |
| "\1\162\16\0\7\uffff"; |
| static final String DFA87_acceptS = |
| "\17\uffff\1\3\1\4\1\5\1\7\1\1\1\2\1\6"; |
| static final String DFA87_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+ |
| "\1\15\7\uffff}>"; |
| static final String[] DFA87_transitionS = { |
| "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+ |
| "\17\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+ |
| "\1\16\1\20\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+ |
| "\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13\7\uffff\1\22\35\uffff"+ |
| "\1\1", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA87_eot = DFA.unpackEncodedString(DFA87_eotS); |
| static final short[] DFA87_eof = DFA.unpackEncodedString(DFA87_eofS); |
| static final char[] DFA87_min = DFA.unpackEncodedStringToUnsignedChars(DFA87_minS); |
| static final char[] DFA87_max = DFA.unpackEncodedStringToUnsignedChars(DFA87_maxS); |
| static final short[] DFA87_accept = DFA.unpackEncodedString(DFA87_acceptS); |
| static final short[] DFA87_special = DFA.unpackEncodedString(DFA87_specialS); |
| static final short[][] DFA87_transition; |
| |
| static { |
| int numStates = DFA87_transitionS.length; |
| DFA87_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA87_transition[i] = DFA.unpackEncodedString(DFA87_transitionS[i]); |
| } |
| } |
| |
| class DFA87 extends DFA { |
| |
| public DFA87(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 87; |
| this.eot = DFA87_eot; |
| this.eof = DFA87_eof; |
| this.min = DFA87_min; |
| this.max = DFA87_max; |
| this.accept = DFA87_accept; |
| this.special = DFA87_special; |
| this.transition = DFA87_transition; |
| } |
| public String getDescription() { |
| return "772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA87_1 = input.LA(1); |
| |
| |
| int index87_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA87_2 = input.LA(1); |
| |
| |
| int index87_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA87_3 = input.LA(1); |
| |
| |
| int index87_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA87_4 = input.LA(1); |
| |
| |
| int index87_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA87_5 = input.LA(1); |
| |
| |
| int index87_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_5); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA87_6 = input.LA(1); |
| |
| |
| int index87_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_6); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA87_7 = input.LA(1); |
| |
| |
| int index87_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_7); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA87_8 = input.LA(1); |
| |
| |
| int index87_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_8); |
| if ( s>=0 ) return s; |
| break; |
| case 8 : |
| int LA87_9 = input.LA(1); |
| |
| |
| int index87_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_9); |
| if ( s>=0 ) return s; |
| break; |
| case 9 : |
| int LA87_10 = input.LA(1); |
| |
| |
| int index87_10 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_10); |
| if ( s>=0 ) return s; |
| break; |
| case 10 : |
| int LA87_11 = input.LA(1); |
| |
| |
| int index87_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_11); |
| if ( s>=0 ) return s; |
| break; |
| case 11 : |
| int LA87_12 = input.LA(1); |
| |
| |
| int index87_12 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| else if ( (synpred119_Java()) ) {s = 15;} |
| |
| else if ( (synpred120_Java()) ) {s = 16;} |
| |
| else if ( (synpred121_Java()) ) {s = 17;} |
| |
| else if ( (synpred122_Java()) ) {s = 21;} |
| |
| |
| input.seek(index87_12); |
| if ( s>=0 ) return s; |
| break; |
| case 12 : |
| int LA87_13 = input.LA(1); |
| |
| |
| int index87_13 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| |
| input.seek(index87_13); |
| if ( s>=0 ) return s; |
| break; |
| case 13 : |
| int LA87_14 = input.LA(1); |
| |
| |
| int index87_14 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred117_Java()) ) {s = 19;} |
| |
| else if ( (synpred118_Java()) ) {s = 20;} |
| |
| |
| input.seek(index87_14); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 87, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA90_eotS = |
| "\54\uffff"; |
| static final String DFA90_eofS = |
| "\54\uffff"; |
| static final String DFA90_minS = |
| "\1\4\4\0\6\uffff\1\0\40\uffff"; |
| static final String DFA90_maxS = |
| "\1\162\4\0\6\uffff\1\0\40\uffff"; |
| static final String DFA90_acceptS = |
| "\5\uffff\1\2\14\uffff\1\3\30\uffff\1\1"; |
| static final String DFA90_specialS = |
| "\1\uffff\1\0\1\1\1\2\1\3\6\uffff\1\4\40\uffff}>"; |
| static final String[] DFA90_transitionS = { |
| "\1\3\11\22\16\uffff\1\5\1\22\1\4\1\22\1\4\2\uffff\1\4\1\5\1"+ |
| "\uffff\1\22\1\uffff\1\22\1\4\1\uffff\1\5\1\uffff\1\1\1\uffff"+ |
| "\1\4\1\22\1\uffff\1\22\3\uffff\1\4\1\5\1\4\1\5\1\22\1\uffff"+ |
| "\3\5\1\22\1\4\2\5\2\22\1\13\2\22\1\uffff\1\5\2\22\1\5\2\22\1"+ |
| "\uffff\1\22\3\uffff\1\22\4\uffff\2\22\5\uffff\4\22\16\uffff"+ |
| "\1\2", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA90_eot = DFA.unpackEncodedString(DFA90_eotS); |
| static final short[] DFA90_eof = DFA.unpackEncodedString(DFA90_eofS); |
| static final char[] DFA90_min = DFA.unpackEncodedStringToUnsignedChars(DFA90_minS); |
| static final char[] DFA90_max = DFA.unpackEncodedStringToUnsignedChars(DFA90_maxS); |
| static final short[] DFA90_accept = DFA.unpackEncodedString(DFA90_acceptS); |
| static final short[] DFA90_special = DFA.unpackEncodedString(DFA90_specialS); |
| static final short[][] DFA90_transition; |
| |
| static { |
| int numStates = DFA90_transitionS.length; |
| DFA90_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA90_transition[i] = DFA.unpackEncodedString(DFA90_transitionS[i]); |
| } |
| } |
| |
| class DFA90 extends DFA { |
| |
| public DFA90(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 90; |
| this.eot = DFA90_eot; |
| this.eof = DFA90_eof; |
| this.min = DFA90_min; |
| this.max = DFA90_max; |
| this.accept = DFA90_accept; |
| this.special = DFA90_special; |
| this.transition = DFA90_transition; |
| } |
| public String getDescription() { |
| return "823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA90_1 = input.LA(1); |
| |
| |
| int index90_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_Java()) ) {s = 43;} |
| |
| else if ( (synpred126_Java()) ) {s = 5;} |
| |
| |
| input.seek(index90_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA90_2 = input.LA(1); |
| |
| |
| int index90_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_Java()) ) {s = 43;} |
| |
| else if ( (synpred126_Java()) ) {s = 5;} |
| |
| |
| input.seek(index90_2); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA90_3 = input.LA(1); |
| |
| |
| int index90_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_Java()) ) {s = 43;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index90_3); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA90_4 = input.LA(1); |
| |
| |
| int index90_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred125_Java()) ) {s = 43;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index90_4); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA90_11 = input.LA(1); |
| |
| |
| int index90_11 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred126_Java()) ) {s = 5;} |
| |
| else if ( (true) ) {s = 18;} |
| |
| |
| input.seek(index90_11); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 90, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA98_eotS = |
| "\40\uffff"; |
| static final String DFA98_eofS = |
| "\40\uffff"; |
| static final String DFA98_minS = |
| "\1\4\1\uffff\1\0\23\uffff\1\0\11\uffff"; |
| static final String DFA98_maxS = |
| "\1\143\1\uffff\1\0\23\uffff\1\0\11\uffff"; |
| static final String DFA98_acceptS = |
| "\1\uffff\1\1\1\uffff\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"+ |
| "\15\1\16\1\17\15\uffff\1\21\1\2\1\3\1\20"; |
| static final String DFA98_specialS = |
| "\2\uffff\1\0\23\uffff\1\1\11\uffff}>"; |
| static final String[] DFA98_transitionS = { |
| "\1\26\11\16\17\uffff\1\2\1\16\1\14\1\16\2\uffff\1\16\2\uffff"+ |
| "\1\15\1\uffff\1\6\1\16\5\uffff\1\16\1\4\1\uffff\1\3\3\uffff"+ |
| "\1\16\1\uffff\1\16\1\uffff\1\16\4\uffff\1\12\1\16\2\uffff\1"+ |
| "\16\1\10\1\11\1\16\1\13\2\uffff\1\7\1\16\1\uffff\1\5\1\16\1"+ |
| "\uffff\1\1\3\uffff\1\34\4\uffff\2\16\5\uffff\4\16", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA98_eot = DFA.unpackEncodedString(DFA98_eotS); |
| static final short[] DFA98_eof = DFA.unpackEncodedString(DFA98_eofS); |
| static final char[] DFA98_min = DFA.unpackEncodedStringToUnsignedChars(DFA98_minS); |
| static final char[] DFA98_max = DFA.unpackEncodedStringToUnsignedChars(DFA98_maxS); |
| static final short[] DFA98_accept = DFA.unpackEncodedString(DFA98_acceptS); |
| static final short[] DFA98_special = DFA.unpackEncodedString(DFA98_specialS); |
| static final short[][] DFA98_transition; |
| |
| static { |
| int numStates = DFA98_transitionS.length; |
| DFA98_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA98_transition[i] = DFA.unpackEncodedString(DFA98_transitionS[i]); |
| } |
| } |
| |
| class DFA98 extends DFA { |
| |
| public DFA98(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 98; |
| this.eot = DFA98_eot; |
| this.eof = DFA98_eof; |
| this.min = DFA98_min; |
| this.max = DFA98_max; |
| this.accept = DFA98_accept; |
| this.special = DFA98_special; |
| this.transition = DFA98_transition; |
| } |
| public String getDescription() { |
| return "842:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA98_2 = input.LA(1); |
| |
| |
| int index98_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred130_Java()) ) {s = 29;} |
| |
| else if ( (synpred132_Java()) ) {s = 30;} |
| |
| |
| input.seek(index98_2); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA98_22 = input.LA(1); |
| |
| |
| int index98_22 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred148_Java()) ) {s = 14;} |
| |
| else if ( (synpred149_Java()) ) {s = 31;} |
| |
| |
| input.seek(index98_22); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 98, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA109_eotS = |
| "\21\uffff"; |
| static final String DFA109_eofS = |
| "\21\uffff"; |
| static final String DFA109_minS = |
| "\1\4\2\uffff\2\0\14\uffff"; |
| static final String DFA109_maxS = |
| "\1\162\2\uffff\2\0\14\uffff"; |
| static final String DFA109_acceptS = |
| "\1\uffff\1\1\3\uffff\1\2\13\uffff"; |
| static final String DFA109_specialS = |
| "\3\uffff\1\0\1\1\14\uffff}>"; |
| static final String[] DFA109_transitionS = { |
| "\1\3\11\5\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\3"+ |
| "\uffff\1\1\1\uffff\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\5\5"+ |
| "\uffff\1\4\2\uffff\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\12"+ |
| "\uffff\2\5\5\uffff\4\5\16\uffff\1\1", |
| "", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA109_eot = DFA.unpackEncodedString(DFA109_eotS); |
| static final short[] DFA109_eof = DFA.unpackEncodedString(DFA109_eofS); |
| static final char[] DFA109_min = DFA.unpackEncodedStringToUnsignedChars(DFA109_minS); |
| static final char[] DFA109_max = DFA.unpackEncodedStringToUnsignedChars(DFA109_maxS); |
| static final short[] DFA109_accept = DFA.unpackEncodedString(DFA109_acceptS); |
| static final short[] DFA109_special = DFA.unpackEncodedString(DFA109_specialS); |
| static final short[][] DFA109_transition; |
| |
| static { |
| int numStates = DFA109_transitionS.length; |
| DFA109_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA109_transition[i] = DFA.unpackEncodedString(DFA109_transitionS[i]); |
| } |
| } |
| |
| class DFA109 extends DFA { |
| |
| public DFA109(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 109; |
| this.eot = DFA109_eot; |
| this.eof = DFA109_eof; |
| this.min = DFA109_min; |
| this.max = DFA109_max; |
| this.accept = DFA109_accept; |
| this.special = DFA109_special; |
| this.transition = DFA109_transition; |
| } |
| public String getDescription() { |
| return "928:1: forInit : ( localVariableDeclaration | expressionList );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA109_3 = input.LA(1); |
| |
| |
| int index109_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred161_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 5;} |
| |
| |
| input.seek(index109_3); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA109_4 = input.LA(1); |
| |
| |
| int index109_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred161_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 5;} |
| |
| |
| input.seek(index109_4); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 109, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA112_eotS = |
| "\17\uffff"; |
| static final String DFA112_eofS = |
| "\17\uffff"; |
| static final String DFA112_minS = |
| "\1\130\12\uffff\1\164\1\130\2\uffff"; |
| static final String DFA112_maxS = |
| "\1\165\12\uffff\2\164\2\uffff"; |
| static final String DFA112_acceptS = |
| "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\2\uffff\1\13"+ |
| "\1\14"; |
| static final String DFA112_specialS = |
| "\17\uffff}>"; |
| static final String[] DFA112_transitionS = { |
| "\1\1\21\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\2\uffff\1\13"+ |
| "\1\12", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "\1\14", |
| "\1\16\33\uffff\1\15", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS); |
| static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS); |
| static final char[] DFA112_min = DFA.unpackEncodedStringToUnsignedChars(DFA112_minS); |
| static final char[] DFA112_max = DFA.unpackEncodedStringToUnsignedChars(DFA112_maxS); |
| static final short[] DFA112_accept = DFA.unpackEncodedString(DFA112_acceptS); |
| static final short[] DFA112_special = DFA.unpackEncodedString(DFA112_specialS); |
| static final short[][] DFA112_transition; |
| |
| static { |
| int numStates = DFA112_transitionS.length; |
| DFA112_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA112_transition[i] = DFA.unpackEncodedString(DFA112_transitionS[i]); |
| } |
| } |
| |
| class DFA112 extends DFA { |
| |
| public DFA112(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 112; |
| this.eot = DFA112_eot; |
| this.eof = DFA112_eof; |
| this.min = DFA112_min; |
| this.max = DFA112_max; |
| this.accept = DFA112_accept; |
| this.special = DFA112_special; |
| this.transition = DFA112_transition; |
| } |
| public String getDescription() { |
| return "951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| } |
| static final String DFA130_eotS = |
| "\14\uffff"; |
| static final String DFA130_eofS = |
| "\14\uffff"; |
| static final String DFA130_minS = |
| "\1\4\2\uffff\1\0\10\uffff"; |
| static final String DFA130_maxS = |
| "\1\132\2\uffff\1\0\10\uffff"; |
| static final String DFA130_acceptS = |
| "\1\uffff\1\1\1\2\1\uffff\1\4\6\uffff\1\3"; |
| static final String DFA130_specialS = |
| "\3\uffff\1\0\10\uffff}>"; |
| static final String[] DFA130_transitionS = { |
| "\12\4\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\5\uffff"+ |
| "\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\4\5\uffff\1\4\2\uffff"+ |
| "\1\4\2\uffff\1\4\4\uffff\1\4\2\uffff\1\3\12\uffff\1\2\1\1", |
| "", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA130_eot = DFA.unpackEncodedString(DFA130_eotS); |
| static final short[] DFA130_eof = DFA.unpackEncodedString(DFA130_eofS); |
| static final char[] DFA130_min = DFA.unpackEncodedStringToUnsignedChars(DFA130_minS); |
| static final char[] DFA130_max = DFA.unpackEncodedStringToUnsignedChars(DFA130_maxS); |
| static final short[] DFA130_accept = DFA.unpackEncodedString(DFA130_acceptS); |
| static final short[] DFA130_special = DFA.unpackEncodedString(DFA130_specialS); |
| static final short[][] DFA130_transition; |
| |
| static { |
| int numStates = DFA130_transitionS.length; |
| DFA130_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA130_transition[i] = DFA.unpackEncodedString(DFA130_transitionS[i]); |
| } |
| } |
| |
| class DFA130 extends DFA { |
| |
| public DFA130(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 130; |
| this.eot = DFA130_eot; |
| this.eof = DFA130_eof; |
| this.min = DFA130_min; |
| this.max = DFA130_max; |
| this.accept = DFA130_accept; |
| this.special = DFA130_special; |
| this.transition = DFA130_transition; |
| } |
| public String getDescription() { |
| return "1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA130_3 = input.LA(1); |
| |
| |
| int index130_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred202_Java()) ) {s = 11;} |
| |
| else if ( (true) ) {s = 4;} |
| |
| |
| input.seek(index130_3); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 130, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA133_eotS = |
| "\41\uffff"; |
| static final String DFA133_eofS = |
| "\1\4\40\uffff"; |
| static final String DFA133_minS = |
| "\1\65\1\0\1\uffff\1\0\35\uffff"; |
| static final String DFA133_maxS = |
| "\1\165\1\0\1\uffff\1\0\35\uffff"; |
| static final String DFA133_acceptS = |
| "\2\uffff\1\1\1\uffff\1\2\34\uffff"; |
| static final String DFA133_specialS = |
| "\1\uffff\1\0\1\uffff\1\1\35\uffff}>"; |
| static final String[] DFA133_transitionS = { |
| "\1\4\30\uffff\1\2\1\4\1\uffff\1\4\1\1\3\4\1\3\1\uffff\1\4\2"+ |
| "\uffff\27\4\1\uffff\3\4", |
| "\1\uffff", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA133_eot = DFA.unpackEncodedString(DFA133_eotS); |
| static final short[] DFA133_eof = DFA.unpackEncodedString(DFA133_eofS); |
| static final char[] DFA133_min = DFA.unpackEncodedStringToUnsignedChars(DFA133_minS); |
| static final char[] DFA133_max = DFA.unpackEncodedStringToUnsignedChars(DFA133_maxS); |
| static final short[] DFA133_accept = DFA.unpackEncodedString(DFA133_acceptS); |
| static final short[] DFA133_special = DFA.unpackEncodedString(DFA133_specialS); |
| static final short[][] DFA133_transition; |
| |
| static { |
| int numStates = DFA133_transitionS.length; |
| DFA133_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA133_transition[i] = DFA.unpackEncodedString(DFA133_transitionS[i]); |
| } |
| } |
| |
| class DFA133 extends DFA { |
| |
| public DFA133(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 133; |
| this.eot = DFA133_eot; |
| this.eof = DFA133_eof; |
| this.min = DFA133_min; |
| this.max = DFA133_max; |
| this.accept = DFA133_accept; |
| this.special = DFA133_special; |
| this.transition = DFA133_transition; |
| } |
| public String getDescription() { |
| return "1105:9: ( identifierSuffix )?"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA133_1 = input.LA(1); |
| |
| |
| int index133_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred209_Java()) ) {s = 2;} |
| |
| else if ( (true) ) {s = 4;} |
| |
| |
| input.seek(index133_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA133_3 = input.LA(1); |
| |
| |
| int index133_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred209_Java()) ) {s = 2;} |
| |
| else if ( (true) ) {s = 4;} |
| |
| |
| input.seek(index133_3); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 133, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA135_eotS = |
| "\41\uffff"; |
| static final String DFA135_eofS = |
| "\1\4\40\uffff"; |
| static final String DFA135_minS = |
| "\1\65\1\0\1\uffff\1\0\35\uffff"; |
| static final String DFA135_maxS = |
| "\1\165\1\0\1\uffff\1\0\35\uffff"; |
| static final String DFA135_acceptS = |
| "\2\uffff\1\1\1\uffff\1\2\34\uffff"; |
| static final String DFA135_specialS = |
| "\1\uffff\1\0\1\uffff\1\1\35\uffff}>"; |
| static final String[] DFA135_transitionS = { |
| "\1\4\30\uffff\1\2\1\4\1\uffff\1\4\1\1\3\4\1\3\1\uffff\1\4\2"+ |
| "\uffff\27\4\1\uffff\3\4", |
| "\1\uffff", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA135_eot = DFA.unpackEncodedString(DFA135_eotS); |
| static final short[] DFA135_eof = DFA.unpackEncodedString(DFA135_eofS); |
| static final char[] DFA135_min = DFA.unpackEncodedStringToUnsignedChars(DFA135_minS); |
| static final char[] DFA135_max = DFA.unpackEncodedStringToUnsignedChars(DFA135_maxS); |
| static final short[] DFA135_accept = DFA.unpackEncodedString(DFA135_acceptS); |
| static final short[] DFA135_special = DFA.unpackEncodedString(DFA135_specialS); |
| static final short[][] DFA135_transition; |
| |
| static { |
| int numStates = DFA135_transitionS.length; |
| DFA135_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA135_transition[i] = DFA.unpackEncodedString(DFA135_transitionS[i]); |
| } |
| } |
| |
| class DFA135 extends DFA { |
| |
| public DFA135(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 135; |
| this.eot = DFA135_eot; |
| this.eof = DFA135_eof; |
| this.min = DFA135_min; |
| this.max = DFA135_max; |
| this.accept = DFA135_accept; |
| this.special = DFA135_special; |
| this.transition = DFA135_transition; |
| } |
| public String getDescription() { |
| return "1110:9: ( identifierSuffix )?"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA135_1 = input.LA(1); |
| |
| |
| int index135_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred212_Java()) ) {s = 2;} |
| |
| else if ( (true) ) {s = 4;} |
| |
| |
| input.seek(index135_1); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA135_3 = input.LA(1); |
| |
| |
| int index135_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred212_Java()) ) {s = 2;} |
| |
| else if ( (true) ) {s = 4;} |
| |
| |
| input.seek(index135_3); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 135, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA143_eotS = |
| "\13\uffff"; |
| static final String DFA143_eofS = |
| "\13\uffff"; |
| static final String DFA143_minS = |
| "\1\116\1\4\1\uffff\1\44\7\uffff"; |
| static final String DFA143_maxS = |
| "\1\126\1\143\1\uffff\1\165\7\uffff"; |
| static final String DFA143_acceptS = |
| "\2\uffff\1\3\1\uffff\1\1\1\2\1\4\1\6\1\7\1\10\1\5"; |
| static final String DFA143_specialS = |
| "\13\uffff}>"; |
| static final String[] DFA143_transitionS = { |
| "\1\2\3\uffff\1\1\3\uffff\1\3", |
| "\12\5\20\uffff\1\5\1\uffff\1\5\2\uffff\1\5\5\uffff\1\5\5\uffff"+ |
| "\1\5\6\uffff\1\5\1\uffff\1\5\1\uffff\1\5\5\uffff\1\5\2\uffff"+ |
| "\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\4\uffff\1\4\5\uffff"+ |
| "\2\5\5\uffff\4\5", |
| "", |
| "\1\6\25\uffff\1\11\10\uffff\1\10\2\uffff\1\7\56\uffff\1\12", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA143_eot = DFA.unpackEncodedString(DFA143_eotS); |
| static final short[] DFA143_eof = DFA.unpackEncodedString(DFA143_eofS); |
| static final char[] DFA143_min = DFA.unpackEncodedStringToUnsignedChars(DFA143_minS); |
| static final char[] DFA143_max = DFA.unpackEncodedStringToUnsignedChars(DFA143_maxS); |
| static final short[] DFA143_accept = DFA.unpackEncodedString(DFA143_acceptS); |
| static final short[] DFA143_special = DFA.unpackEncodedString(DFA143_specialS); |
| static final short[][] DFA143_transition; |
| |
| static { |
| int numStates = DFA143_transitionS.length; |
| DFA143_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA143_transition[i] = DFA.unpackEncodedString(DFA143_transitionS[i]); |
| } |
| } |
| |
| class DFA143 extends DFA { |
| |
| public DFA143(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 143; |
| this.eot = DFA143_eot; |
| this.eof = DFA143_eof; |
| this.min = DFA143_min; |
| this.max = DFA143_max; |
| this.accept = DFA143_accept; |
| this.special = DFA143_special; |
| this.transition = DFA143_transition; |
| } |
| public String getDescription() { |
| return "1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| } |
| static final String DFA142_eotS = |
| "\41\uffff"; |
| static final String DFA142_eofS = |
| "\1\1\40\uffff"; |
| static final String DFA142_minS = |
| "\1\65\1\uffff\1\0\36\uffff"; |
| static final String DFA142_maxS = |
| "\1\165\1\uffff\1\0\36\uffff"; |
| static final String DFA142_acceptS = |
| "\1\uffff\1\2\36\uffff\1\1"; |
| static final String DFA142_specialS = |
| "\2\uffff\1\0\36\uffff}>"; |
| static final String[] DFA142_transitionS = { |
| "\1\1\31\uffff\1\1\1\uffff\1\1\1\2\4\1\1\uffff\1\1\2\uffff\27"+ |
| "\1\1\uffff\3\1", |
| "", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA142_eot = DFA.unpackEncodedString(DFA142_eotS); |
| static final short[] DFA142_eof = DFA.unpackEncodedString(DFA142_eofS); |
| static final char[] DFA142_min = DFA.unpackEncodedStringToUnsignedChars(DFA142_minS); |
| static final char[] DFA142_max = DFA.unpackEncodedStringToUnsignedChars(DFA142_maxS); |
| static final short[] DFA142_accept = DFA.unpackEncodedString(DFA142_acceptS); |
| static final short[] DFA142_special = DFA.unpackEncodedString(DFA142_specialS); |
| static final short[][] DFA142_transition; |
| |
| static { |
| int numStates = DFA142_transitionS.length; |
| DFA142_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA142_transition[i] = DFA.unpackEncodedString(DFA142_transitionS[i]); |
| } |
| } |
| |
| class DFA142 extends DFA { |
| |
| public DFA142(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 142; |
| this.eot = DFA142_eot; |
| this.eof = DFA142_eof; |
| this.min = DFA142_min; |
| this.max = DFA142_max; |
| this.accept = DFA142_accept; |
| this.special = DFA142_special; |
| this.transition = DFA142_transition; |
| } |
| public String getDescription() { |
| return "()+ loopback of 1138:9: ( '[' expression ']' )+"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA142_2 = input.LA(1); |
| |
| |
| int index142_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred224_Java()) ) {s = 32;} |
| |
| else if ( (true) ) {s = 1;} |
| |
| |
| input.seek(index142_2); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 142, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA148_eotS = |
| "\41\uffff"; |
| static final String DFA148_eofS = |
| "\1\2\40\uffff"; |
| static final String DFA148_minS = |
| "\1\65\1\0\37\uffff"; |
| static final String DFA148_maxS = |
| "\1\165\1\0\37\uffff"; |
| static final String DFA148_acceptS = |
| "\2\uffff\1\2\35\uffff\1\1"; |
| static final String DFA148_specialS = |
| "\1\uffff\1\0\37\uffff}>"; |
| static final String[] DFA148_transitionS = { |
| "\1\2\31\uffff\1\2\1\uffff\1\2\1\1\4\2\1\uffff\1\2\2\uffff\27"+ |
| "\2\1\uffff\3\2", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA148_eot = DFA.unpackEncodedString(DFA148_eotS); |
| static final short[] DFA148_eof = DFA.unpackEncodedString(DFA148_eofS); |
| static final char[] DFA148_min = DFA.unpackEncodedStringToUnsignedChars(DFA148_minS); |
| static final char[] DFA148_max = DFA.unpackEncodedStringToUnsignedChars(DFA148_maxS); |
| static final short[] DFA148_accept = DFA.unpackEncodedString(DFA148_acceptS); |
| static final short[] DFA148_special = DFA.unpackEncodedString(DFA148_specialS); |
| static final short[][] DFA148_transition; |
| |
| static { |
| int numStates = DFA148_transitionS.length; |
| DFA148_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA148_transition[i] = DFA.unpackEncodedString(DFA148_transitionS[i]); |
| } |
| } |
| |
| class DFA148 extends DFA { |
| |
| public DFA148(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 148; |
| this.eot = DFA148_eot; |
| this.eof = DFA148_eof; |
| this.min = DFA148_min; |
| this.max = DFA148_max; |
| this.accept = DFA148_accept; |
| this.special = DFA148_special; |
| this.transition = DFA148_transition; |
| } |
| public String getDescription() { |
| return "()* loopback of 1176:9: ( '[' expression ']' )*"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA148_1 = input.LA(1); |
| |
| |
| int index148_1 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred240_Java()) ) {s = 32;} |
| |
| else if ( (true) ) {s = 2;} |
| |
| |
| input.seek(index148_1); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 148, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| static final String DFA171_eotS = |
| "\55\uffff"; |
| static final String DFA171_eofS = |
| "\55\uffff"; |
| static final String DFA171_minS = |
| "\1\4\1\uffff\10\0\43\uffff"; |
| static final String DFA171_maxS = |
| "\1\165\1\uffff\10\0\43\uffff"; |
| static final String DFA171_acceptS = |
| "\1\uffff\1\1\10\uffff\1\2\42\uffff"; |
| static final String DFA171_specialS = |
| "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>"; |
| static final String[] DFA171_transitionS = { |
| "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+ |
| "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+ |
| "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+ |
| "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+ |
| "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+ |
| "\1\12\2\uffff\1\1", |
| "", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "\1\uffff", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "", |
| "" |
| }; |
| |
| static final short[] DFA171_eot = DFA.unpackEncodedString(DFA171_eotS); |
| static final short[] DFA171_eof = DFA.unpackEncodedString(DFA171_eofS); |
| static final char[] DFA171_min = DFA.unpackEncodedStringToUnsignedChars(DFA171_minS); |
| static final char[] DFA171_max = DFA.unpackEncodedStringToUnsignedChars(DFA171_maxS); |
| static final short[] DFA171_accept = DFA.unpackEncodedString(DFA171_acceptS); |
| static final short[] DFA171_special = DFA.unpackEncodedString(DFA171_specialS); |
| static final short[][] DFA171_transition; |
| |
| static { |
| int numStates = DFA171_transitionS.length; |
| DFA171_transition = new short[numStates][]; |
| for (int i=0; i<numStates; i++) { |
| DFA171_transition[i] = DFA.unpackEncodedString(DFA171_transitionS[i]); |
| } |
| } |
| |
| class DFA171 extends DFA { |
| |
| public DFA171(BaseRecognizer recognizer) { |
| this.recognizer = recognizer; |
| this.decisionNumber = 171; |
| this.eot = DFA171_eot; |
| this.eof = DFA171_eof; |
| this.min = DFA171_min; |
| this.max = DFA171_max; |
| this.accept = DFA171_accept; |
| this.special = DFA171_special; |
| this.transition = DFA171_transition; |
| } |
| public String getDescription() { |
| return "521:9: ( explicitConstructorInvocation )?"; |
| } |
| public void error(NoViableAltException nvae) { |
| dbg.recognitionException(nvae); |
| } |
| public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { |
| TokenStream input = (TokenStream)_input; |
| int _s = s; |
| switch ( s ) { |
| case 0 : |
| int LA171_2 = input.LA(1); |
| |
| |
| int index171_2 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_2); |
| if ( s>=0 ) return s; |
| break; |
| case 1 : |
| int LA171_3 = input.LA(1); |
| |
| |
| int index171_3 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_3); |
| if ( s>=0 ) return s; |
| break; |
| case 2 : |
| int LA171_4 = input.LA(1); |
| |
| |
| int index171_4 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_4); |
| if ( s>=0 ) return s; |
| break; |
| case 3 : |
| int LA171_5 = input.LA(1); |
| |
| |
| int index171_5 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_5); |
| if ( s>=0 ) return s; |
| break; |
| case 4 : |
| int LA171_6 = input.LA(1); |
| |
| |
| int index171_6 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_6); |
| if ( s>=0 ) return s; |
| break; |
| case 5 : |
| int LA171_7 = input.LA(1); |
| |
| |
| int index171_7 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_7); |
| if ( s>=0 ) return s; |
| break; |
| case 6 : |
| int LA171_8 = input.LA(1); |
| |
| |
| int index171_8 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_8); |
| if ( s>=0 ) return s; |
| break; |
| case 7 : |
| int LA171_9 = input.LA(1); |
| |
| |
| int index171_9 = input.index(); |
| input.rewind(); |
| s = -1; |
| if ( (synpred57_Java()) ) {s = 1;} |
| |
| else if ( (true) ) {s = 10;} |
| |
| |
| input.seek(index171_9); |
| if ( s>=0 ) return s; |
| break; |
| } |
| if (state.backtracking>0) {state.failed=true; return -1;} |
| NoViableAltException nvae = |
| new NoViableAltException(getDescription(), 171, _s, input); |
| error(nvae); |
| throw nvae; |
| } |
| } |
| |
| |
| public static final BitSet FOLLOW_annotations_in_compilationUnit64 = new BitSet(new long[]{0x0800000000000000L}); |
| public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit93 = new BitSet(new long[]{0x7290281010000002L,0x0004000000101226L}); |
| public static final BitSet FOLLOW_importDeclaration_in_compilationUnit115 = new BitSet(new long[]{0x7290281010000002L,0x0004000000101226L}); |
| public static final BitSet FOLLOW_typeDeclaration_in_compilationUnit137 = new BitSet(new long[]{0x7280281010000002L,0x0004000000101226L}); |
| public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration167 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedName_in_packageDeclaration169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_packageDeclaration179 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IMPORT_in_importDeclaration198 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_STATIC_in_importDeclaration209 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration230 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_importDeclaration232 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); |
| public static final BitSet FOLLOW_STAR_in_importDeclaration234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_importDeclaration244 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IMPORT_in_importDeclaration254 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000002L}); |
| public static final BitSet FOLLOW_STATIC_in_importDeclaration265 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration286 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_importDeclaration297 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration299 = new BitSet(new long[]{0x0000000000000000L,0x0000000000500000L}); |
| public static final BitSet FOLLOW_DOT_in_importDeclaration321 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); |
| public static final BitSet FOLLOW_STAR_in_importDeclaration323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_importDeclaration344 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName363 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_qualifiedImportName374 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName376 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_typeDeclaration416 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotation_in_modifiers473 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_PUBLIC_in_modifiers483 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_PROTECTED_in_modifiers493 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_PRIVATE_in_modifiers503 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_STATIC_in_modifiers513 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_ABSTRACT_in_modifiers523 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_FINAL_in_modifiers533 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_NATIVE_in_modifiers543 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_SYNCHRONIZED_in_modifiers553 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_TRANSIENT_in_modifiers563 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_VOLATILE_in_modifiers573 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_STRICTFP_in_modifiers583 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); |
| public static final BitSet FOLLOW_FINAL_in_variableModifiers614 = new BitSet(new long[]{0x0000200000000002L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_annotation_in_variableModifiers628 = new BitSet(new long[]{0x0000200000000002L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_normalClassDeclaration_in_classDeclaration659 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_enumDeclaration_in_classDeclaration669 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_normalClassDeclaration688 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_normalClassDeclaration691 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_normalClassDeclaration693 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_typeParameters_in_normalClassDeclaration704 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_EXTENDS_in_normalClassDeclaration726 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_normalClassDeclaration728 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_IMPLEMENTS_in_normalClassDeclaration750 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_typeList_in_normalClassDeclaration752 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_classBody_in_normalClassDeclaration773 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LT_in_typeParameters793 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_typeParameter_in_typeParameters807 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_typeParameters822 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_typeParameter_in_typeParameters824 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); |
| public static final BitSet FOLLOW_GT_in_typeParameters849 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_typeParameter868 = new BitSet(new long[]{0x0000100000000002L}); |
| public static final BitSet FOLLOW_EXTENDS_in_typeParameter879 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_typeBound_in_typeParameter881 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_type_in_typeBound912 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); |
| public static final BitSet FOLLOW_AMP_in_typeBound923 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_typeBound925 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); |
| public static final BitSet FOLLOW_modifiers_in_enumDeclaration956 = new BitSet(new long[]{0x0000080000000000L}); |
| public static final BitSet FOLLOW_ENUM_in_enumDeclaration967 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_enumDeclaration987 = new BitSet(new long[]{0x0008000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_IMPLEMENTS_in_enumDeclaration998 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_typeList_in_enumDeclaration1000 = new BitSet(new long[]{0x0008000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_enumBody_in_enumDeclaration1021 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACE_in_enumBody1041 = new BitSet(new long[]{0x0000000000000010L,0x0004000000320000L}); |
| public static final BitSet FOLLOW_enumConstants_in_enumBody1052 = new BitSet(new long[]{0x0000000000000000L,0x0000000000320000L}); |
| public static final BitSet FOLLOW_COMMA_in_enumBody1073 = new BitSet(new long[]{0x0000000000000000L,0x0000000000120000L}); |
| public static final BitSet FOLLOW_enumBodyDeclarations_in_enumBody1085 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_RBRACE_in_enumBody1106 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_enumConstant_in_enumConstants1125 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_enumConstants1136 = new BitSet(new long[]{0x0000000000000010L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_enumConstant_in_enumConstants1138 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_annotations_in_enumConstant1171 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant1192 = new BitSet(new long[]{0x0008100000000002L,0x0020000000014000L}); |
| public static final BitSet FOLLOW_arguments_in_enumConstant1203 = new BitSet(new long[]{0x0008100000000002L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_classBody_in_enumConstant1225 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_enumBodyDeclarations1265 = new BitSet(new long[]{0x73C0AA1950000012L,0x0024000000111A27L}); |
| public static final BitSet FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276 = new BitSet(new long[]{0x73C0AA1950000012L,0x0024000000111A27L}); |
| public static final BitSet FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_normalInterfaceDeclaration1335 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_typeParameters_in_normalInterfaceDeclaration1350 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_typeList_in_normalInterfaceDeclaration1374 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_type_in_typeList1414 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_typeList1425 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_typeList1427 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_LBRACE_in_classBody1457 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000131A27L}); |
| public static final BitSet FOLLOW_classBodyDeclaration_in_classBody1468 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000131A27L}); |
| public static final BitSet FOLLOW_RBRACE_in_classBody1489 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACE_in_interfaceBody1508 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000121A27L}); |
| public static final BitSet FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000121A27L}); |
| public static final BitSet FOLLOW_RBRACE_in_interfaceBody1540 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_classBodyDeclaration1559 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_STATIC_in_classBodyDeclaration1570 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_classBodyDeclaration1591 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_memberDecl_in_classBodyDeclaration1601 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_fieldDeclaration_in_memberDecl1621 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_methodDeclaration_in_memberDecl1632 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classDeclaration_in_memberDecl1643 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceDeclaration_in_memberDecl1654 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_methodDeclaration1691 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_typeParameters_in_methodDeclaration1702 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration1723 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_formalParameters_in_methodDeclaration1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010100L}); |
| public static final BitSet FOLLOW_THROWS_in_methodDeclaration1744 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration1746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_LBRACE_in_methodDeclaration1767 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_blockStatement_in_methodDeclaration1800 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_RBRACE_in_methodDeclaration1821 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_methodDeclaration1831 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L}); |
| public static final BitSet FOLLOW_typeParameters_in_methodDeclaration1842 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L}); |
| public static final BitSet FOLLOW_type_in_methodDeclaration1864 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_VOID_in_methodDeclaration1878 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration1898 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_formalParameters_in_methodDeclaration1908 = new BitSet(new long[]{0x0000000000000000L,0x0000000000150102L}); |
| public static final BitSet FOLLOW_LBRACKET_in_methodDeclaration1919 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_methodDeclaration1921 = new BitSet(new long[]{0x0000000000000000L,0x0000000000150102L}); |
| public static final BitSet FOLLOW_THROWS_in_methodDeclaration1943 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration1945 = new BitSet(new long[]{0x0000000000000000L,0x0000000000110002L}); |
| public static final BitSet FOLLOW_block_in_methodDeclaration1980 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_methodDeclaration1994 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_fieldDeclaration2024 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_fieldDeclaration2034 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2044 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); |
| public static final BitSet FOLLOW_COMMA_in_fieldDeclaration2055 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); |
| public static final BitSet FOLLOW_SEMI_in_fieldDeclaration2078 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_variableDeclarator2097 = new BitSet(new long[]{0x0000000000000002L,0x0000000001040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_variableDeclarator2108 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_variableDeclarator2110 = new BitSet(new long[]{0x0000000000000002L,0x0000000001040000L}); |
| public static final BitSet FOLLOW_EQ_in_variableDeclarator2132 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06014849L}); |
| public static final BitSet FOLLOW_variableInitializer_in_variableDeclarator2134 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_interfaceBodyDeclaration2212 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_interfaceMethodDeclaration2231 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L}); |
| public static final BitSet FOLLOW_typeParameters_in_interfaceMethodDeclaration2242 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L}); |
| public static final BitSet FOLLOW_type_in_interfaceMethodDeclaration2264 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_VOID_in_interfaceMethodDeclaration2275 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_formalParameters_in_interfaceMethodDeclaration2305 = new BitSet(new long[]{0x0000000000000000L,0x0000000000140100L}); |
| public static final BitSet FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318 = new BitSet(new long[]{0x0000000000000000L,0x0000000000140100L}); |
| public static final BitSet FOLLOW_THROWS_in_interfaceMethodDeclaration2340 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_interfaceMethodDeclaration2355 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_interfaceFieldDeclaration2376 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_interfaceFieldDeclaration2378 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); |
| public static final BitSet FOLLOW_COMMA_in_interfaceFieldDeclaration2391 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); |
| public static final BitSet FOLLOW_SEMI_in_interfaceFieldDeclaration2414 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classOrInterfaceType_in_type2434 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_type2445 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_type2447 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_primitiveType_in_type2468 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_type2479 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_type2481 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType2512 = new BitSet(new long[]{0x0000000000000002L,0x0020000000400000L}); |
| public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType2523 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_classOrInterfaceType2545 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType2547 = new BitSet(new long[]{0x0000000000000002L,0x0020000000400000L}); |
| public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType2562 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_set_in_primitiveType0 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LT_in_typeArguments2696 = new BitSet(new long[]{0x0140820940000010L,0x0000000008000001L}); |
| public static final BitSet FOLLOW_typeArgument_in_typeArguments2698 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_typeArguments2709 = new BitSet(new long[]{0x0140820940000010L,0x0000000008000001L}); |
| public static final BitSet FOLLOW_typeArgument_in_typeArguments2711 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); |
| public static final BitSet FOLLOW_GT_in_typeArguments2732 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_type_in_typeArgument2751 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_QUES_in_typeArgument2761 = new BitSet(new long[]{0x0000100000000002L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_set_in_typeArgument2785 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_typeArgument2829 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList2859 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_qualifiedNameList2870 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList2872 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_LPAREN_in_formalParameters2902 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000008001L}); |
| public static final BitSet FOLLOW_formalParameterDecls_in_formalParameters2913 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_formalParameters2934 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2963 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_formalParameterDecls2974 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); |
| public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2976 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_formalParameterDecls3008 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); |
| public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_variableModifiers_in_normalParameterDecl3048 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_normalParameterDecl3050 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_normalParameterDecl3052 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_normalParameterDecl3063 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_normalParameterDecl3065 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_variableModifiers_in_ellipsisParameterDecl3095 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_ellipsisParameterDecl3105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); |
| public static final BitSet FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000048L}); |
| public static final BitSet FOLLOW_set_in_explicitConstructorInvocation3165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3199 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_primary_in_explicitConstructorInvocation3210 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_explicitConstructorInvocation3220 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000008L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_SUPER_in_explicitConstructorInvocation3252 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3264 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3283 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_qualifiedName3294 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3296 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_annotation_in_annotations3327 = new BitSet(new long[]{0x0000000000000002L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_MONKEYS_AT_in_annotation3359 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedName_in_annotation3361 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_annotation3375 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F0601C849L}); |
| public static final BitSet FOLLOW_elementValuePairs_in_annotation3399 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_elementValue_in_annotation3423 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_annotation3458 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs3488 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_elementValuePairs3499 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs3501 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_elementValuePair3531 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_EQ_in_elementValuePair3533 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L}); |
| public static final BitSet FOLLOW_elementValue_in_elementValuePair3535 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_conditionalExpression_in_elementValue3554 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotation_in_elementValue3564 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_elementValueArrayInitializer_in_elementValue3574 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACE_in_elementValueArrayInitializer3593 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06234849L}); |
| public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer3604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); |
| public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer3619 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L}); |
| public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer3621 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); |
| public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer3650 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_RBRACE_in_elementValueArrayInitializer3654 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_annotationTypeDeclaration3676 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_INTERFACE_in_annotationTypeDeclaration3688 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACE_in_annotationTypeBody3728 = new BitSet(new long[]{0x73C0AA1950000010L,0x0004000000121227L}); |
| public static final BitSet FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739 = new BitSet(new long[]{0x73C0AA1950000010L,0x0004000000121227L}); |
| public static final BitSet FOLLOW_RBRACE_in_annotationTypeBody3760 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_annotationTypeElementDeclaration3841 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_annotationMethodDeclaration3860 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_annotationMethodDeclaration3862 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_annotationMethodDeclaration3874 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_annotationMethodDeclaration3876 = new BitSet(new long[]{0x0000008000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_DEFAULT_in_annotationMethodDeclaration3879 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L}); |
| public static final BitSet FOLLOW_elementValue_in_annotationMethodDeclaration3881 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_annotationMethodDeclaration3910 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACE_in_block3933 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_blockStatement_in_block3944 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_RBRACE_in_block3965 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_localVariableDeclarationStatement_in_blockStatement3986 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_statement_in_blockStatement4006 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_localVariableDeclarationStatement4036 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_variableModifiers_in_localVariableDeclaration4055 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_localVariableDeclaration4057 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4067 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_localVariableDeclaration4078 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4080 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_block_in_statement4110 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ASSERT_in_statement4122 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_statement4142 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); |
| public static final BitSet FOLLOW_COLON_in_statement4145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_statement4147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4151 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ASSERT_in_statement4161 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_statement4164 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); |
| public static final BitSet FOLLOW_COLON_in_statement4167 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_statement4169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4173 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IF_in_statement4183 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_parExpression_in_statement4185 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_statement4187 = new BitSet(new long[]{0x0000040000000002L}); |
| public static final BitSet FOLLOW_ELSE_in_statement4190 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_statement4192 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_forstatement_in_statement4204 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_WHILE_in_statement4214 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_parExpression_in_statement4216 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_statement4218 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DO_in_statement4228 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_statement4230 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); |
| public static final BitSet FOLLOW_WHILE_in_statement4232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_parExpression_in_statement4234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4236 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_trystatement_in_statement4246 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SWITCH_in_statement4256 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_parExpression_in_statement4258 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_LBRACE_in_statement4260 = new BitSet(new long[]{0x0000008200000000L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_switchBlockStatementGroups_in_statement4262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_RBRACE_in_statement4264 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SYNCHRONIZED_in_statement4274 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_parExpression_in_statement4276 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_statement4278 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_RETURN_in_statement4288 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06104849L}); |
| public static final BitSet FOLLOW_expression_in_statement4291 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4296 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_THROW_in_statement4306 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_statement4308 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4310 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_BREAK_in_statement4320 = new BitSet(new long[]{0x0000000000000010L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_statement4335 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4352 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_CONTINUE_in_statement4362 = new BitSet(new long[]{0x0000000000000010L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_statement4377 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4394 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_expression_in_statement4404 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4407 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_statement4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_statement4419 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_statement4421 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SEMI_in_statement4431 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452 = new BitSet(new long[]{0x0000008200000002L}); |
| public static final BitSet FOLLOW_switchLabel_in_switchBlockStatementGroup4480 = new BitSet(new long[]{0xF7C5AB59F0003FF2L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_blockStatement_in_switchBlockStatementGroup4491 = new BitSet(new long[]{0xF7C5AB59F0003FF2L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_CASE_in_switchLabel4521 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_switchLabel4523 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_switchLabel4525 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DEFAULT_in_switchLabel4535 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_switchLabel4537 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_TRY_in_trystatement4557 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_trystatement4559 = new BitSet(new long[]{0x0000400400000000L}); |
| public static final BitSet FOLLOW_catches_in_trystatement4573 = new BitSet(new long[]{0x0000400000000000L}); |
| public static final BitSet FOLLOW_FINALLY_in_trystatement4575 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_trystatement4577 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_catches_in_trystatement4591 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_FINALLY_in_trystatement4605 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_trystatement4607 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_catchClause_in_catches4637 = new BitSet(new long[]{0x0000000400000002L}); |
| public static final BitSet FOLLOW_catchClause_in_catches4648 = new BitSet(new long[]{0x0000000400000002L}); |
| public static final BitSet FOLLOW_CATCH_in_catchClause4678 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_catchClause4680 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); |
| public static final BitSet FOLLOW_formalParameter_in_catchClause4682 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_catchClause4692 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_catchClause4694 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_variableModifiers_in_formalParameter4713 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_formalParameter4715 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_formalParameter4717 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_formalParameter4728 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_formalParameter4730 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_FOR_in_forstatement4775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_forstatement4777 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); |
| public static final BitSet FOLLOW_variableModifiers_in_forstatement4779 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_forstatement4781 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_forstatement4783 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_forstatement4785 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_forstatement4795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_forstatement4797 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_forstatement4799 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_FOR_in_forstatement4819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_forstatement4821 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F06104849L}); |
| public static final BitSet FOLLOW_forInit_in_forstatement4840 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_forstatement4861 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06104849L}); |
| public static final BitSet FOLLOW_expression_in_forstatement4880 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_forstatement4901 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F0600C849L}); |
| public static final BitSet FOLLOW_expressionList_in_forstatement4920 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_forstatement4941 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_forstatement4943 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_localVariableDeclaration_in_forInit4962 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_expressionList_in_forInit4972 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LPAREN_in_parExpression4991 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_parExpression4993 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_parExpression4995 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_expression_in_expressionList5014 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_expressionList5025 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_expressionList5027 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_conditionalExpression_in_expression5058 = new BitSet(new long[]{0x0000000000000002L,0x0033FC0001000000L}); |
| public static final BitSet FOLLOW_assignmentOperator_in_expression5069 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_expression5071 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_EQ_in_assignmentOperator5102 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_PLUSEQ_in_assignmentOperator5112 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SUBEQ_in_assignmentOperator5122 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_STAREQ_in_assignmentOperator5132 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SLASHEQ_in_assignmentOperator5142 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_AMPEQ_in_assignmentOperator5152 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_BAREQ_in_assignmentOperator5162 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_CARETEQ_in_assignmentOperator5172 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_PERCENTEQ_in_assignmentOperator5182 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LT_in_assignmentOperator5193 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_LT_in_assignmentOperator5195 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_EQ_in_assignmentOperator5197 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_GT_in_assignmentOperator5208 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_assignmentOperator5210 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_assignmentOperator5212 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_EQ_in_assignmentOperator5214 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_GT_in_assignmentOperator5225 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_assignmentOperator5227 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_EQ_in_assignmentOperator5229 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_conditionalOrExpression_in_conditionalExpression5249 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L}); |
| public static final BitSet FOLLOW_QUES_in_conditionalExpression5260 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_conditionalExpression5262 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_conditionalExpression5264 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression5266 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296 = new BitSet(new long[]{0x0000000000000002L,0x0000000080000000L}); |
| public static final BitSet FOLLOW_BARBAR_in_conditionalOrExpression5307 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309 = new BitSet(new long[]{0x0000000000000002L,0x0000000080000000L}); |
| public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L}); |
| public static final BitSet FOLLOW_AMPAMP_in_conditionalAndExpression5350 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L}); |
| public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L}); |
| public static final BitSet FOLLOW_BAR_in_inclusiveOrExpression5393 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L}); |
| public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression5425 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L}); |
| public static final BitSet FOLLOW_CARET_in_exclusiveOrExpression5436 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression5438 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L}); |
| public static final BitSet FOLLOW_equalityExpression_in_andExpression5468 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); |
| public static final BitSet FOLLOW_AMP_in_andExpression5479 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_equalityExpression_in_andExpression5481 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); |
| public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression5511 = new BitSet(new long[]{0x0000000000000002L,0x0008000020000000L}); |
| public static final BitSet FOLLOW_set_in_equalityExpression5535 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression5585 = new BitSet(new long[]{0x0000000000000002L,0x0008000020000000L}); |
| public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression5615 = new BitSet(new long[]{0x0020000000000002L}); |
| public static final BitSet FOLLOW_INSTANCEOF_in_instanceOfExpression5626 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_instanceOfExpression5628 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_shiftExpression_in_relationalExpression5658 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); |
| public static final BitSet FOLLOW_relationalOp_in_relationalExpression5669 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_shiftExpression_in_relationalExpression5671 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); |
| public static final BitSet FOLLOW_LT_in_relationalOp5702 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_EQ_in_relationalOp5704 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_GT_in_relationalOp5715 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); |
| public static final BitSet FOLLOW_EQ_in_relationalOp5717 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LT_in_relationalOp5727 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_GT_in_relationalOp5737 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_additiveExpression_in_shiftExpression5756 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); |
| public static final BitSet FOLLOW_shiftOp_in_shiftExpression5767 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_additiveExpression_in_shiftExpression5769 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); |
| public static final BitSet FOLLOW_LT_in_shiftOp5801 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_LT_in_shiftOp5803 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_GT_in_shiftOp5814 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_shiftOp5816 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_shiftOp5818 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_GT_in_shiftOp5829 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_shiftOp5831 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression5851 = new BitSet(new long[]{0x0000000000000002L,0x0000000C00000000L}); |
| public static final BitSet FOLLOW_set_in_additiveExpression5875 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression5925 = new BitSet(new long[]{0x0000000000000002L,0x0000000C00000000L}); |
| public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5962 = new BitSet(new long[]{0x0000000000000002L,0x0000023000000000L}); |
| public static final BitSet FOLLOW_set_in_multiplicativeExpression5986 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression6054 = new BitSet(new long[]{0x0000000000000002L,0x0000023000000000L}); |
| public static final BitSet FOLLOW_PLUS_in_unaryExpression6086 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6089 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SUB_in_unaryExpression6099 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6101 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_PLUSPLUS_in_unaryExpression6111 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6113 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SUBSUB_in_unaryExpression6123 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6125 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_primary_in_unaryExpressionNotPlusMinus6188 = new BitSet(new long[]{0x0000000000000002L,0x0000000300440000L}); |
| public static final BitSet FOLLOW_selector_in_unaryExpressionNotPlusMinus6199 = new BitSet(new long[]{0x0000000000000002L,0x0000000300440000L}); |
| public static final BitSet FOLLOW_set_in_unaryExpressionNotPlusMinus6220 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LPAREN_in_castExpression6268 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_primitiveType_in_castExpression6270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_castExpression6272 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_castExpression6274 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LPAREN_in_castExpression6284 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_castExpression6286 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_castExpression6288 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_parExpression_in_primary6311 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_THIS_in_primary6321 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); |
| public static final BitSet FOLLOW_DOT_in_primary6332 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_primary6334 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); |
| public static final BitSet FOLLOW_identifierSuffix_in_primary6356 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_primary6377 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); |
| public static final BitSet FOLLOW_DOT_in_primary6388 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_primary6390 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); |
| public static final BitSet FOLLOW_identifierSuffix_in_primary6412 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_SUPER_in_primary6433 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L}); |
| public static final BitSet FOLLOW_superSuffix_in_primary6443 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_literal_in_primary6453 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_creator_in_primary6463 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_primitiveType_in_primary6473 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_primary6484 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_primary6486 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L}); |
| public static final BitSet FOLLOW_DOT_in_primary6507 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_primary6509 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_VOID_in_primary6519 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); |
| public static final BitSet FOLLOW_DOT_in_primary6521 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_primary6523 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_arguments_in_superSuffix6543 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_superSuffix6553 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_typeArguments_in_superSuffix6556 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_superSuffix6577 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_superSuffix6588 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix6620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix6622 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L}); |
| public static final BitSet FOLLOW_DOT_in_identifierSuffix6643 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_identifierSuffix6645 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix6656 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_identifierSuffix6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix6660 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_arguments_in_identifierSuffix6681 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_identifierSuffix6691 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_identifierSuffix6693 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_identifierSuffix6703 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_identifierSuffix6707 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_identifierSuffix6709 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_identifierSuffix6719 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); |
| public static final BitSet FOLLOW_THIS_in_identifierSuffix6721 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_identifierSuffix6731 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_SUPER_in_identifierSuffix6733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_identifierSuffix6735 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_innerCreator_in_identifierSuffix6745 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_selector6765 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_selector6767 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_selector6778 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_selector6799 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); |
| public static final BitSet FOLLOW_THIS_in_selector6801 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_selector6811 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); |
| public static final BitSet FOLLOW_SUPER_in_selector6813 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L}); |
| public static final BitSet FOLLOW_superSuffix_in_selector6823 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_innerCreator_in_selector6833 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACKET_in_selector6843 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_selector6845 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_selector6847 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_creator6866 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_creator6868 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_classOrInterfaceType_in_creator6870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_classCreatorRest_in_creator6872 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_creator6882 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_classOrInterfaceType_in_creator6884 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_classCreatorRest_in_creator6886 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_arrayCreator_in_creator6896 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_arrayCreator6915 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_createdName_in_arrayCreator6917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6927 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); |
| public static final BitSet FOLLOW_arrayInitializer_in_arrayCreator6963 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_arrayCreator6974 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_createdName_in_arrayCreator6976 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6986 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_arrayCreator6988 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6998 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_arrayCreator7012 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_arrayCreator7014 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_arrayCreator7028 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_arrayCreator7050 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_arrayCreator7052 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_arrayInitializer_in_variableInitializer7082 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_expression_in_variableInitializer7092 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACE_in_arrayInitializer7111 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06234849L}); |
| public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer7126 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); |
| public static final BitSet FOLLOW_COMMA_in_arrayInitializer7145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06014849L}); |
| public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer7147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); |
| public static final BitSet FOLLOW_COMMA_in_arrayInitializer7196 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); |
| public static final BitSet FOLLOW_RBRACE_in_arrayInitializer7208 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classOrInterfaceType_in_createdName7241 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_primitiveType_in_createdName7251 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_innerCreator7270 = new BitSet(new long[]{0x0400000000000000L}); |
| public static final BitSet FOLLOW_NEW_in_innerCreator7272 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_innerCreator7283 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_innerCreator7304 = new BitSet(new long[]{0x0000000000000000L,0x0020000000004000L}); |
| public static final BitSet FOLLOW_typeArguments_in_innerCreator7315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_classCreatorRest_in_innerCreator7336 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_arguments_in_classCreatorRest7356 = new BitSet(new long[]{0x0008100000000002L,0x0020000000010000L}); |
| public static final BitSet FOLLOW_classBody_in_classCreatorRest7367 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LT_in_nonWildcardTypeArguments7398 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_typeList_in_nonWildcardTypeArguments7400 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); |
| public static final BitSet FOLLOW_GT_in_nonWildcardTypeArguments7410 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LPAREN_in_arguments7429 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F0600C849L}); |
| public static final BitSet FOLLOW_expressionList_in_arguments7432 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_arguments7445 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_classHeader7566 = new BitSet(new long[]{0x0000001000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_classHeader7568 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_classHeader7570 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_enumHeader7589 = new BitSet(new long[]{0x0000080000000010L}); |
| public static final BitSet FOLLOW_set_in_enumHeader7591 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_enumHeader7597 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_interfaceHeader7616 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_INTERFACE_in_interfaceHeader7618 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_interfaceHeader7620 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_annotationHeader7639 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_MONKEYS_AT_in_annotationHeader7641 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_INTERFACE_in_annotationHeader7643 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_annotationHeader7645 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_typeHeader7664 = new BitSet(new long[]{0x0080081000000000L,0x0004000000000000L}); |
| public static final BitSet FOLLOW_CLASS_in_typeHeader7667 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_ENUM_in_typeHeader7669 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_MONKEYS_AT_in_typeHeader7672 = new BitSet(new long[]{0x0080000000000000L}); |
| public static final BitSet FOLLOW_INTERFACE_in_typeHeader7676 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_typeHeader7680 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_methodHeader7699 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L}); |
| public static final BitSet FOLLOW_typeParameters_in_methodHeader7701 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L}); |
| public static final BitSet FOLLOW_type_in_methodHeader7705 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_VOID_in_methodHeader7707 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_methodHeader7711 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_methodHeader7713 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_fieldHeader7732 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_fieldHeader7734 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_fieldHeader7736 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_fieldHeader7739 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_fieldHeader7740 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); |
| public static final BitSet FOLLOW_set_in_fieldHeader7744 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_variableModifiers_in_localVariableHeader7769 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_localVariableHeader7771 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_localVariableHeader7773 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_localVariableHeader7776 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_localVariableHeader7777 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); |
| public static final BitSet FOLLOW_set_in_localVariableHeader7781 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotations_in_synpred2_Java64 = new BitSet(new long[]{0x0800000000000000L}); |
| public static final BitSet FOLLOW_packageDeclaration_in_synpred2_Java93 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classDeclaration_in_synpred12_Java436 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalClassDeclaration_in_synpred27_Java659 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_fieldDeclaration_in_synpred52_Java1621 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_methodDeclaration_in_synpred53_Java1632 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classDeclaration_in_synpred54_Java1643 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_modifiers_in_synpred59_Java1691 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_typeParameters_in_synpred59_Java1702 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_synpred59_Java1723 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_formalParameters_in_synpred59_Java1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010100L}); |
| public static final BitSet FOLLOW_THROWS_in_synpred59_Java1744 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_qualifiedNameList_in_synpred59_Java1746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); |
| public static final BitSet FOLLOW_LBRACE_in_synpred59_Java1767 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_blockStatement_in_synpred59_Java1800 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); |
| public static final BitSet FOLLOW_RBRACE_in_synpred59_Java1821 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceDeclaration_in_synpred70_Java2192 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classDeclaration_in_synpred71_Java2202 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalParameterDecl_in_synpred98_Java2963 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_synpred98_Java2974 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); |
| public static final BitSet FOLLOW_normalParameterDecl_in_synpred98_Java2976 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_normalParameterDecl_in_synpred99_Java2998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); |
| public static final BitSet FOLLOW_COMMA_in_synpred99_Java3008 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000048L}); |
| public static final BitSet FOLLOW_set_in_synpred103_Java3165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_arguments_in_synpred103_Java3197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_synpred103_Java3199 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalClassDeclaration_in_synpred119_Java3801 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_enumDeclaration_in_synpred121_Java3821 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ASSERT_in_synpred130_Java4122 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred130_Java4142 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); |
| public static final BitSet FOLLOW_COLON_in_synpred130_Java4145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred130_Java4147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_synpred130_Java4151 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ASSERT_in_synpred132_Java4161 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred132_Java4164 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); |
| public static final BitSet FOLLOW_COLON_in_synpred132_Java4167 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred132_Java4169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_synpred132_Java4173 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_ELSE_in_synpred133_Java4190 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_synpred133_Java4192 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_expression_in_synpred148_Java4404 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); |
| public static final BitSet FOLLOW_SEMI_in_synpred148_Java4407 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_synpred149_Java4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_synpred149_Java4419 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_synpred149_Java4421 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_catches_in_synpred153_Java4573 = new BitSet(new long[]{0x0000400000000000L}); |
| public static final BitSet FOLLOW_FINALLY_in_synpred153_Java4575 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); |
| public static final BitSet FOLLOW_block_in_synpred153_Java4577 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_catches_in_synpred154_Java4591 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_FOR_in_synpred157_Java4775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_LPAREN_in_synpred157_Java4777 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); |
| public static final BitSet FOLLOW_variableModifiers_in_synpred157_Java4779 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_type_in_synpred157_Java4781 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_synpred157_Java4783 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); |
| public static final BitSet FOLLOW_COLON_in_synpred157_Java4785 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred157_Java4795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_synpred157_Java4797 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); |
| public static final BitSet FOLLOW_statement_in_synpred157_Java4799 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_localVariableDeclaration_in_synpred161_Java4962 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_castExpression_in_synpred202_Java6178 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LPAREN_in_synpred206_Java6268 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_primitiveType_in_synpred206_Java6270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); |
| public static final BitSet FOLLOW_RPAREN_in_synpred206_Java6272 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_unaryExpression_in_synpred206_Java6274 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_synpred208_Java6332 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_synpred208_Java6334 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_identifierSuffix_in_synpred209_Java6356 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_DOT_in_synpred211_Java6388 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_IDENTIFIER_in_synpred211_Java6390 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_identifierSuffix_in_synpred212_Java6412 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACKET_in_synpred224_Java6656 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred224_Java6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_synpred224_Java6660 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_synpred236_Java6866 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); |
| public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_classOrInterfaceType_in_synpred236_Java6870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_classCreatorRest_in_synpred236_Java6872 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_synpred237_Java6882 = new BitSet(new long[]{0x0000000000000010L}); |
| public static final BitSet FOLLOW_classOrInterfaceType_in_synpred237_Java6884 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); |
| public static final BitSet FOLLOW_classCreatorRest_in_synpred237_Java6886 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_NEW_in_synpred239_Java6915 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); |
| public static final BitSet FOLLOW_createdName_in_synpred239_Java6917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_synpred239_Java6927 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_synpred239_Java6929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); |
| public static final BitSet FOLLOW_LBRACKET_in_synpred239_Java6940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_synpred239_Java6942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); |
| public static final BitSet FOLLOW_arrayInitializer_in_synpred239_Java6963 = new BitSet(new long[]{0x0000000000000002L}); |
| public static final BitSet FOLLOW_LBRACKET_in_synpred240_Java7012 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); |
| public static final BitSet FOLLOW_expression_in_synpred240_Java7014 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); |
| public static final BitSet FOLLOW_RBRACKET_in_synpred240_Java7028 = new BitSet(new long[]{0x0000000000000002L}); |
| |
| } |