1 /* 2 * Copyright (C) 2011 Google Inc. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.doclava.parser; 18 19 import org.antlr.runtime.BaseRecognizer; 20 import org.antlr.runtime.BitSet; 21 import org.antlr.runtime.DFA; 22 import org.antlr.runtime.EarlyExitException; 23 import org.antlr.runtime.IntStream; 24 import org.antlr.runtime.MismatchedSetException; 25 import org.antlr.runtime.NoViableAltException; 26 import org.antlr.runtime.RecognitionException; 27 import org.antlr.runtime.RecognizerSharedState; 28 import org.antlr.runtime.TokenStream; 29 import org.antlr.runtime.debug.DebugEventListener; 30 import org.antlr.runtime.debug.DebugEventSocketProxy; 31 import org.antlr.runtime.debug.DebugParser; 32 33 import java.io.IOException; 34 import java.util.HashMap; 35 /** A Java 1.5 grammar for ANTLR v3 derived from the spec 36 * 37 * This is a very close representation of the spec; the changes 38 * are comestic (remove left recursion) and also fixes (the spec 39 * isn't exactly perfect). I have run this on the 1.4.2 source 40 * and some nasty looking enums from 1.5, but have not really 41 * tested for 1.5 compatibility. 42 * 43 * I built this with: java -Xmx100M org.antlr.Tool java.g 44 * and got two errors that are ok (for now): 45 * java.g:691:9: Decision can match input such as 46 * "'0'..'9'{'E', 'e'}{'+', '-'}'0'..'9'{'D', 'F', 'd', 'f'}" 47 * using multiple alternatives: 3, 4 48 * As a result, alternative(s) 4 were disabled for that input 49 * java.g:734:35: Decision can match input such as "{'$', 'A'..'Z', 50 * '_', 'a'..'z', '\u00C0'..'\u00D6', '\u00D8'..'\u00F6', 51 * '\u00F8'..'\u1FFF', '\u3040'..'\u318F', '\u3300'..'\u337F', 52 * '\u3400'..'\u3D2D', '\u4E00'..'\u9FFF', '\uF900'..'\uFAFF'}" 53 * using multiple alternatives: 1, 2 54 * As a result, alternative(s) 2 were disabled for that input 55 * 56 * You can turn enum on/off as a keyword :) 57 * 58 * Version 1.0 -- initial release July 5, 2006 (requires 3.0b2 or higher) 59 * 60 * Primary author: Terence Parr, July 2006 61 * 62 * Version 1.0.1 -- corrections by Koen Vanderkimpen & Marko van Dooren, 63 * October 25, 2006; 64 * fixed normalInterfaceDeclaration: now uses typeParameters instead 65 * of typeParameter (according to JLS, 3rd edition) 66 * fixed castExpression: no longer allows expression next to type 67 * (according to semantics in JLS, in contrast with syntax in JLS) 68 * 69 * Version 1.0.2 -- Terence Parr, Nov 27, 2006 70 * java spec I built this from had some bizarre for-loop control. 71 * Looked weird and so I looked elsewhere...Yep, it's messed up. 72 * simplified. 73 * 74 * Version 1.0.3 -- Chris Hogue, Feb 26, 2007 75 * Factored out an annotationName rule and used it in the annotation rule. 76 * Not sure why, but typeName wasn't recognizing references to inner 77 * annotations (e.g. @InterfaceName.InnerAnnotation()) 78 * Factored out the elementValue section of an annotation reference. Created 79 * elementValuePair and elementValuePairs rules, then used them in the 80 * annotation rule. Allows it to recognize annotation references with 81 * multiple, comma separated attributes. 82 * Updated elementValueArrayInitializer so that it allows multiple elements. 83 * (It was only allowing 0 or 1 element). 84 * Updated localVariableDeclaration to allow annotations. Interestingly the JLS 85 * doesn't appear to indicate this is legal, but it does work as of at least 86 * JDK 1.5.0_06. 87 * Moved the Identifier portion of annotationTypeElementRest to annotationMethodRest. 88 * Because annotationConstantRest already references variableDeclarator which 89 * has the Identifier portion in it, the parser would fail on constants in 90 * annotation definitions because it expected two identifiers. 91 * Added optional trailing ';' to the alternatives in annotationTypeElementRest. 92 * Wouldn't handle an inner interface that has a trailing ';'. 93 * Swapped the expression and type rule reference order in castExpression to 94 * make it check for genericized casts first. It was failing to recognize a 95 * statement like "Class<Byte> TYPE = (Class<Byte>)...;" because it was seeing 96 * 'Class<Byte' in the cast expression as a less than expression, then failing 97 * on the '>'. 98 * Changed createdName to use typeArguments instead of nonWildcardTypeArguments. 99 * 100 * Changed the 'this' alternative in primary to allow 'identifierSuffix' rather than 101 * just 'arguments'. The case it couldn't handle was a call to an explicit 102 * generic method invocation (e.g. this.<E>doSomething()). Using identifierSuffix 103 * may be overly aggressive--perhaps should create a more constrained thisSuffix rule? 104 * 105 * Version 1.0.4 -- Hiroaki Nakamura, May 3, 2007 106 * 107 * Fixed formalParameterDecls, localVariableDeclaration, forInit, 108 * and forVarControl to use variableModifier* not 'final'? (annotation)? 109 * 110 * Version 1.0.5 -- Terence, June 21, 2007 111 * --a[i].foo didn't work. Fixed unaryExpression 112 * 113 * Version 1.0.6 -- John Ridgway, March 17, 2008 114 * Made "assert" a switchable keyword like "enum". 115 * Fixed compilationUnit to disallow "annotation importDeclaration ...". 116 * Changed "Identifier ('.' Identifier)*" to "qualifiedName" in more 117 * places. 118 * Changed modifier* and/or variableModifier* to classOrInterfaceModifiers, 119 * modifiers or variableModifiers, as appropriate. 120 * Renamed "bound" to "typeBound" to better match language in the JLS. 121 * Added "memberDeclaration" which rewrites to methodDeclaration or 122 * fieldDeclaration and pulled type into memberDeclaration. So we parse 123 * type and then move on to decide whether we're dealing with a field 124 * or a method. 125 * Modified "constructorDeclaration" to use "constructorBody" instead of 126 * "methodBody". constructorBody starts with explicitConstructorInvocation, 127 * then goes on to blockStatement*. Pulling explicitConstructorInvocation 128 * out of expressions allowed me to simplify "primary". 129 * Changed variableDeclarator to simplify it. 130 * Changed type to use classOrInterfaceType, thus simplifying it; of course 131 * I then had to add classOrInterfaceType, but it is used in several 132 * places. 133 * Fixed annotations, old version allowed "@X(y,z)", which is illegal. 134 * Added optional comma to end of "elementValueArrayInitializer"; as per JLS. 135 * Changed annotationTypeElementRest to use normalClassDeclaration and 136 * normalInterfaceDeclaration rather than classDeclaration and 137 * interfaceDeclaration, thus getting rid of a couple of grammar ambiguities. 138 * Split localVariableDeclaration into localVariableDeclarationStatement 139 * (includes the terminating semi-colon) and localVariableDeclaration. 140 * This allowed me to use localVariableDeclaration in "forInit" clauses, 141 * simplifying them. 142 * Changed switchBlockStatementGroup to use multiple labels. This adds an 143 * ambiguity, but if one uses appropriately greedy parsing it yields the 144 * parse that is closest to the meaning of the switch statement. 145 * Renamed "forVarControl" to "enhancedForControl" -- JLS language. 146 * Added semantic predicates to test for shift operations rather than other 147 * things. Thus, for instance, the string "< <" will never be treated 148 * as a left-shift operator. 149 * In "creator" we rule out "nonWildcardTypeArguments" on arrayCreation, 150 * which are illegal. 151 * Moved "nonWildcardTypeArguments into innerCreator. 152 * Removed 'super' superSuffix from explicitGenericInvocation, since that 153 * is only used in explicitConstructorInvocation at the beginning of a 154 * constructorBody. (This is part of the simplification of expressions 155 * mentioned earlier.) 156 * Simplified primary (got rid of those things that are only used in 157 * explicitConstructorInvocation). 158 * Lexer -- removed "Exponent?" from FloatingPointLiteral choice 4, since it 159 * led to an ambiguity. 160 * 161 * This grammar successfully parses every .java file in the JDK 1.5 source 162 * tree (excluding those whose file names include '-', which are not 163 * valid Java compilation units). 164 * 165 * Known remaining problems: 166 * "Letter" and "JavaIDDigit" are wrong. The actual specification of 167 * "Letter" should be "a character for which the method 168 * Character.isJavaIdentifierStart(int) returns true." A "Java 169 * letter-or-digit is a character for which the method 170 * Character.isJavaIdentifierPart(int) returns true." 171 */ 172 public class JavaParser extends DebugParser { 173 public static final String[] tokenNames = new String[] { 174 "<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" 175 }; 176 public static final int EOF=-1; 177 public static final int IDENTIFIER=4; 178 public static final int INTLITERAL=5; 179 public static final int LONGLITERAL=6; 180 public static final int FLOATLITERAL=7; 181 public static final int DOUBLELITERAL=8; 182 public static final int CHARLITERAL=9; 183 public static final int STRINGLITERAL=10; 184 public static final int TRUE=11; 185 public static final int FALSE=12; 186 public static final int NULL=13; 187 public static final int IntegerNumber=14; 188 public static final int LongSuffix=15; 189 public static final int HexPrefix=16; 190 public static final int HexDigit=17; 191 public static final int Exponent=18; 192 public static final int NonIntegerNumber=19; 193 public static final int FloatSuffix=20; 194 public static final int DoubleSuffix=21; 195 public static final int EscapeSequence=22; 196 public static final int UNICODECHAR=23; 197 public static final int UNICODEPART=24; 198 public static final int WS=25; 199 public static final int COMMENT=26; 200 public static final int LINE_COMMENT=27; 201 public static final int ABSTRACT=28; 202 public static final int ASSERT=29; 203 public static final int BOOLEAN=30; 204 public static final int BREAK=31; 205 public static final int BYTE=32; 206 public static final int CASE=33; 207 public static final int CATCH=34; 208 public static final int CHAR=35; 209 public static final int CLASS=36; 210 public static final int CONST=37; 211 public static final int CONTINUE=38; 212 public static final int DEFAULT=39; 213 public static final int DO=40; 214 public static final int DOUBLE=41; 215 public static final int ELSE=42; 216 public static final int ENUM=43; 217 public static final int EXTENDS=44; 218 public static final int FINAL=45; 219 public static final int FINALLY=46; 220 public static final int FLOAT=47; 221 public static final int FOR=48; 222 public static final int GOTO=49; 223 public static final int IF=50; 224 public static final int IMPLEMENTS=51; 225 public static final int IMPORT=52; 226 public static final int INSTANCEOF=53; 227 public static final int INT=54; 228 public static final int INTERFACE=55; 229 public static final int LONG=56; 230 public static final int NATIVE=57; 231 public static final int NEW=58; 232 public static final int PACKAGE=59; 233 public static final int PRIVATE=60; 234 public static final int PROTECTED=61; 235 public static final int PUBLIC=62; 236 public static final int RETURN=63; 237 public static final int SHORT=64; 238 public static final int STATIC=65; 239 public static final int STRICTFP=66; 240 public static final int SUPER=67; 241 public static final int SWITCH=68; 242 public static final int SYNCHRONIZED=69; 243 public static final int THIS=70; 244 public static final int THROW=71; 245 public static final int THROWS=72; 246 public static final int TRANSIENT=73; 247 public static final int TRY=74; 248 public static final int VOID=75; 249 public static final int VOLATILE=76; 250 public static final int WHILE=77; 251 public static final int LPAREN=78; 252 public static final int RPAREN=79; 253 public static final int LBRACE=80; 254 public static final int RBRACE=81; 255 public static final int LBRACKET=82; 256 public static final int RBRACKET=83; 257 public static final int SEMI=84; 258 public static final int COMMA=85; 259 public static final int DOT=86; 260 public static final int ELLIPSIS=87; 261 public static final int EQ=88; 262 public static final int BANG=89; 263 public static final int TILDE=90; 264 public static final int QUES=91; 265 public static final int COLON=92; 266 public static final int EQEQ=93; 267 public static final int AMPAMP=94; 268 public static final int BARBAR=95; 269 public static final int PLUSPLUS=96; 270 public static final int SUBSUB=97; 271 public static final int PLUS=98; 272 public static final int SUB=99; 273 public static final int STAR=100; 274 public static final int SLASH=101; 275 public static final int AMP=102; 276 public static final int BAR=103; 277 public static final int CARET=104; 278 public static final int PERCENT=105; 279 public static final int PLUSEQ=106; 280 public static final int SUBEQ=107; 281 public static final int STAREQ=108; 282 public static final int SLASHEQ=109; 283 public static final int AMPEQ=110; 284 public static final int BAREQ=111; 285 public static final int CARETEQ=112; 286 public static final int PERCENTEQ=113; 287 public static final int MONKEYS_AT=114; 288 public static final int BANGEQ=115; 289 public static final int GT=116; 290 public static final int LT=117; 291 public static final int IdentifierStart=118; 292 public static final int IdentifierPart=119; 293 public static final int SurrogateIdentifer=120; 294 295 // delegates 296 // delegators 297 298 public static final String[] ruleNames = new String[] { 299 "invalidRule", "typeList", "synpred114_Java", "synpred175_Java", 300 "synpred19_Java", "elementValuePairs", "identifierSuffix", "interfaceFieldDeclaration", 301 "synpred69_Java", "synpred263_Java", "synpred231_Java", "synpred267_Java", 302 "synpred111_Java", "block", "synpred261_Java", "elementValuePair", 303 "typeArgument", "synpred264_Java", "synpred95_Java", "synpred93_Java", 304 "synpred215_Java", "normalInterfaceDeclaration", "enumHeader", "synpred236_Java", 305 "createdName", "synpred271_Java", "synpred230_Java", "synpred30_Java", 306 "synpred212_Java", "synpred82_Java", "synpred128_Java", "synpred83_Java", 307 "synpred255_Java", "synpred190_Java", "arrayInitializer", "interfaceDeclaration", 308 "synpred92_Java", "localVariableHeader", "packageDeclaration", "formalParameter", 309 "catchClause", "synpred27_Java", "synpred270_Java", "synpred46_Java", 310 "synpred1_Java", "synpred4_Java", "synpred233_Java", "synpred120_Java", 311 "superSuffix", "literal", "classDeclaration", "synpred72_Java", 312 "synpred160_Java", "arguments", "synpred80_Java", "formalParameterDecls", 313 "synpred113_Java", "inclusiveOrExpression", "synpred71_Java", "selector", 314 "synpred194_Java", "synpred265_Java", "synpred173_Java", "synpred141_Java", 315 "synpred187_Java", "trystatement", "synpred133_Java", "interfaceHeader", 316 "synpred73_Java", "localVariableDeclarationStatement", "synpred102_Java", 317 "synpred90_Java", "equalityExpression", "synpred177_Java", "synpred149_Java", 318 "interfaceBodyDeclaration", "classCreatorRest", "synpred121_Java", 319 "synpred105_Java", "typeArguments", "synpred60_Java", "synpred195_Java", 320 "fieldDeclaration", "synpred269_Java", "synpred250_Java", "multiplicativeExpression", 321 "qualifiedNameList", "synpred86_Java", "synpred148_Java", "synpred142_Java", 322 "synpred65_Java", "synpred75_Java", "synpred235_Java", "synpred192_Java", 323 "synpred144_Java", "castExpression", "enumBody", "synpred70_Java", 324 "synpred33_Java", "synpred54_Java", "annotationTypeDeclaration", 325 "annotationHeader", "synpred107_Java", "synpred35_Java", "creator", 326 "nonWildcardTypeArguments", "variableInitializer", "enumConstants", 327 "synpred34_Java", "interfaceMethodDeclaration", "type", "synpred135_Java", 328 "synpred119_Java", "conditionalAndExpression", "synpred9_Java", 329 "synpred125_Java", "synpred40_Java", "synpred257_Java", "enumConstant", 330 "synpred143_Java", "synpred132_Java", "synpred146_Java", "synpred188_Java", 331 "ellipsisParameterDecl", "synpred245_Java", "synpred167_Java", "compilationUnit", 332 "synpred259_Java", "synpred64_Java", "synpred181_Java", "synpred23_Java", 333 "synpred12_Java", "synpred74_Java", "explicitConstructorInvocation", 334 "synpred266_Java", "synpred197_Java", "synpred147_Java", "synpred15_Java", 335 "synpred178_Java", "synpred174_Java", "exclusiveOrExpression", "forstatement", 336 "synpred7_Java", "synpred76_Java", "synpred224_Java", "parExpression", 337 "synpred241_Java", "synpred159_Java", "synpred260_Java", "synpred50_Java", 338 "synpred166_Java", "annotationMethodDeclaration", "synpred208_Java", 339 "synpred106_Java", "classOrInterfaceType", "qualifiedImportName", 340 "statement", "typeBound", "methodHeader", "synpred249_Java", "synpred55_Java", 341 "synpred131_Java", "classBodyDeclaration", "synpred189_Java", "synpred51_Java", 342 "synpred227_Java", "synpred220_Java", "synpred123_Java", "andExpression", 343 "synpred200_Java", "synpred165_Java", "relationalExpression", "annotationTypeBody", 344 "synpred210_Java", "synpred109_Java", "conditionalOrExpression", 345 "synpred161_Java", "classOrInterfaceDeclaration", "synpred180_Java", 346 "synpred154_Java", "elementValueArrayInitializer", "synpred14_Java", 347 "innerCreator", "synpred26_Java", "synpred52_Java", "synpred198_Java", 348 "synpred219_Java", "synpred126_Java", "synpred85_Java", "synpred88_Java", 349 "synpred68_Java", "synpred3_Java", "synpred203_Java", "annotations", 350 "elementValue", "synpred205_Java", "synpred6_Java", "synpred32_Java", 351 "synpred209_Java", "assignmentOperator", "synpred262_Java", "synpred139_Java", 352 "synpred29_Java", "synpred204_Java", "synpred118_Java", "synpred94_Java", 353 "synpred84_Java", "synpred63_Java", "conditionalExpression", "synpred56_Java", 354 "synpred162_Java", "primitiveType", "synpred240_Java", "synpred216_Java", 355 "synpred79_Java", "synpred99_Java", "additiveExpression", "synpred78_Java", 356 "modifiers", "synpred184_Java", "synpred168_Java", "synpred48_Java", 357 "switchBlockStatementGroups", "blockStatement", "synpred193_Java", 358 "classBody", "interfaceBody", "synpred67_Java", "synpred5_Java", 359 "synpred58_Java", "synpred254_Java", "localVariableDeclaration", 360 "annotationTypeElementDeclaration", "synpred251_Java", "arrayCreator", 361 "synpred226_Java", "synpred239_Java", "synpred191_Java", "synpred24_Java", 362 "normalClassDeclaration", "synpred98_Java", "synpred53_Java", "synpred145_Java", 363 "synpred22_Java", "synpred150_Java", "synpred238_Java", "synpred207_Java", 364 "variableModifiers", "typeParameters", "synpred38_Java", "synpred129_Java", 365 "enumBodyDeclarations", "synpred172_Java", "synpred16_Java", "synpred100_Java", 366 "fieldHeader", "synpred41_Java", "synpred248_Java", "synpred152_Java", 367 "synpred214_Java", "switchBlockStatementGroup", "synpred199_Java", 368 "switchLabel", "qualifiedName", "synpred137_Java", "synpred237_Java", 369 "synpred223_Java", "synpred156_Java", "synpred243_Java", "synpred182_Java", 370 "synpred138_Java", "synpred77_Java", "synpred127_Java", "synpred112_Java", 371 "unaryExpressionNotPlusMinus", "synpred42_Java", "synpred89_Java", 372 "formalParameters", "synpred225_Java", "synpred136_Java", "synpred186_Java", 373 "synpred122_Java", "synpred87_Java", "synpred244_Java", "synpred97_Java", 374 "synpred229_Java", "synpred170_Java", "shiftOp", "synpred134_Java", 375 "synpred253_Java", "synpred44_Java", "memberDecl", "synpred157_Java", 376 "synpred246_Java", "synpred49_Java", "synpred31_Java", "synpred256_Java", 377 "unaryExpression", "synpred13_Java", "synpred213_Java", "synpred155_Java", 378 "typeHeader", "synpred91_Java", "instanceOfExpression", "variableDeclarator", 379 "synpred140_Java", "synpred25_Java", "synpred117_Java", "synpred2_Java", 380 "synpred222_Java", "synpred10_Java", "synpred104_Java", "synpred115_Java", 381 "synpred221_Java", "synpred45_Java", "synpred211_Java", "typeParameter", 382 "synpred36_Java", "synpred103_Java", "synpred39_Java", "synpred201_Java", 383 "methodDeclaration", "synpred62_Java", "synpred110_Java", "classHeader", 384 "synpred101_Java", "synpred21_Java", "synpred196_Java", "synpred96_Java", 385 "synpred61_Java", "synpred228_Java", "synpred28_Java", "synpred218_Java", 386 "synpred179_Java", "normalParameterDecl", "enumDeclaration", "synpred17_Java", 387 "synpred18_Java", "synpred108_Java", "synpred43_Java", "synpred206_Java", 388 "synpred169_Java", "synpred130_Java", "synpred242_Java", "synpred252_Java", 389 "synpred151_Java", "forInit", "shiftExpression", "synpred81_Java", 390 "synpred247_Java", "synpred20_Java", "catches", "synpred202_Java", 391 "synpred47_Java", "synpred185_Java", "synpred158_Java", "synpred66_Java", 392 "synpred11_Java", "synpred8_Java", "synpred163_Java", "synpred217_Java", 393 "primary", "synpred153_Java", "synpred57_Java", "synpred258_Java", 394 "expressionList", "annotation", "expression", "synpred176_Java", 395 "synpred171_Java", "synpred164_Java", "importDeclaration", "synpred124_Java", 396 "synpred268_Java", "synpred234_Java", "relationalOp", "synpred59_Java", 397 "synpred37_Java", "synpred183_Java", "synpred232_Java", "synpred116_Java", 398 "typeDeclaration" 399 }; 400 public static final boolean[] decisionCanBacktrack = new boolean[] { 401 false, // invalid decision 402 false, true, false, false, false, false, false, false, false, false, 403 false, true, false, false, true, false, false, false, false, 404 false, false, false, false, false, false, false, false, false, 405 false, false, true, false, false, false, false, false, false, 406 false, true, false, false, true, false, false, false, false, 407 false, false, true, false, false, false, true, false, false, 408 false, false, false, false, false, false, false, false, false, 409 false, false, false, false, false, false, true, true, false, 410 false, false, true, false, false, false, false, false, false, 411 false, false, false, false, true, false, false, true, false, 412 false, false, true, false, false, false, true, false, false, 413 false, true, false, false, false, false, false, true, true, 414 false, false, false, false, false, false, false, false, false, 415 false, false, false, false, false, false, false, false, false, 416 false, false, true, true, true, true, true, true, false, false, 417 false, false, false, false, true, false, false, false, true, 418 false, true, false, true, false, false, false, false, false, 419 false, false, false, false, false, false, false, false, false, 420 false, false, false, false, false, false, true, false, false, 421 false, false, false, false, false, false, false, false, false, 422 false, false, false, false, false, false, false, false, false, 423 false, false, false 424 }; 425 426 427 public int ruleLevel = 0; getRuleLevel()428 public int getRuleLevel() { return ruleLevel; } incRuleLevel()429 public void incRuleLevel() { ruleLevel++; } decRuleLevel()430 public void decRuleLevel() { ruleLevel--; } JavaParser(TokenStream input)431 public JavaParser(TokenStream input) { 432 this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState()); 433 } JavaParser(TokenStream input, int port, RecognizerSharedState state)434 public JavaParser(TokenStream input, int port, RecognizerSharedState state) { 435 super(input, state); 436 this.state.ruleMemo = new HashMap[381+1]; 437 438 DebugEventSocketProxy proxy = 439 new DebugEventSocketProxy(this, port, null); 440 setDebugListener(proxy); 441 try { 442 proxy.handshake(); 443 } 444 catch (IOException ioe) { 445 reportError(ioe); 446 } 447 } JavaParser(TokenStream input, DebugEventListener dbg)448 public JavaParser(TokenStream input, DebugEventListener dbg) { 449 super(input, dbg, new RecognizerSharedState()); 450 this.state.ruleMemo = new HashMap[381+1]; 451 452 } evalPredicate(boolean result, String predicate)453 protected boolean evalPredicate(boolean result, String predicate) { 454 dbg.semanticPredicate(result, predicate); 455 return result; 456 } 457 458 getTokenNames()459 public String[] getTokenNames() { return JavaParser.tokenNames; } getGrammarFileName()460 public String getGrammarFileName() { return "src/com/google/doclava/parser/Java.g"; } 461 462 463 464 // $ANTLR start "compilationUnit" 465 // src/com/google/doclava/parser/Java.g:293:1: compilationUnit : ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ; compilationUnit()466 public final void compilationUnit() throws RecognitionException { 467 int compilationUnit_StartIndex = input.index(); 468 try { dbg.enterRule(getGrammarFileName(), "compilationUnit"); 469 if ( getRuleLevel()==0 ) {dbg.commence();} 470 incRuleLevel(); 471 dbg.location(293, 1); 472 473 try { 474 if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; } 475 // src/com/google/doclava/parser/Java.g:298:5: ( ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ) 476 dbg.enterAlt(1); 477 478 // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* 479 { 480 dbg.location(298,9); 481 // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )? 482 int alt2=2; 483 try { dbg.enterSubRule(2); 484 try { dbg.enterDecision(2, decisionCanBacktrack[2]); 485 486 try { 487 isCyclicDecision = true; 488 alt2 = dfa2.predict(input); 489 } 490 catch (NoViableAltException nvae) { 491 dbg.recognitionException(nvae); 492 throw nvae; 493 } 494 } finally {dbg.exitDecision(2);} 495 496 switch (alt2) { 497 case 1 : 498 dbg.enterAlt(1); 499 500 // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration 501 { 502 dbg.location(298,13); 503 // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? 504 int alt1=2; 505 try { dbg.enterSubRule(1); 506 try { dbg.enterDecision(1, decisionCanBacktrack[1]); 507 508 int LA1_0 = input.LA(1); 509 510 if ( (LA1_0==MONKEYS_AT) ) { 511 alt1=1; 512 } 513 } finally {dbg.exitDecision(1);} 514 515 switch (alt1) { 516 case 1 : 517 dbg.enterAlt(1); 518 519 // src/com/google/doclava/parser/Java.g:298:14: annotations 520 { 521 dbg.location(298,14); 522 pushFollow(FOLLOW_annotations_in_compilationUnit64); 523 annotations(); 524 525 state._fsp--; 526 if (state.failed) return ; 527 528 } 529 break; 530 531 } 532 } finally {dbg.exitSubRule(1);} 533 534 dbg.location(300,13); 535 pushFollow(FOLLOW_packageDeclaration_in_compilationUnit93); 536 packageDeclaration(); 537 538 state._fsp--; 539 if (state.failed) return ; 540 541 } 542 break; 543 544 } 545 } finally {dbg.exitSubRule(2);} 546 547 dbg.location(302,9); 548 // src/com/google/doclava/parser/Java.g:302:9: ( importDeclaration )* 549 try { dbg.enterSubRule(3); 550 551 loop3: 552 do { 553 int alt3=2; 554 try { dbg.enterDecision(3, decisionCanBacktrack[3]); 555 556 int LA3_0 = input.LA(1); 557 558 if ( (LA3_0==IMPORT) ) { 559 alt3=1; 560 } 561 562 563 } finally {dbg.exitDecision(3);} 564 565 switch (alt3) { 566 case 1 : 567 dbg.enterAlt(1); 568 569 // src/com/google/doclava/parser/Java.g:302:10: importDeclaration 570 { 571 dbg.location(302,10); 572 pushFollow(FOLLOW_importDeclaration_in_compilationUnit115); 573 importDeclaration(); 574 575 state._fsp--; 576 if (state.failed) return ; 577 578 } 579 break; 580 581 default : 582 break loop3; 583 } 584 } while (true); 585 } finally {dbg.exitSubRule(3);} 586 587 dbg.location(304,9); 588 // src/com/google/doclava/parser/Java.g:304:9: ( typeDeclaration )* 589 try { dbg.enterSubRule(4); 590 591 loop4: 592 do { 593 int alt4=2; 594 try { dbg.enterDecision(4, decisionCanBacktrack[4]); 595 596 int LA4_0 = input.LA(1); 597 598 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) ) { 599 alt4=1; 600 } 601 602 603 } finally {dbg.exitDecision(4);} 604 605 switch (alt4) { 606 case 1 : 607 dbg.enterAlt(1); 608 609 // src/com/google/doclava/parser/Java.g:304:10: typeDeclaration 610 { 611 dbg.location(304,10); 612 pushFollow(FOLLOW_typeDeclaration_in_compilationUnit137); 613 typeDeclaration(); 614 615 state._fsp--; 616 if (state.failed) return ; 617 618 } 619 break; 620 621 default : 622 break loop4; 623 } 624 } while (true); 625 } finally {dbg.exitSubRule(4);} 626 627 628 } 629 630 } 631 catch (RecognitionException re) { 632 reportError(re); 633 recover(input,re); 634 } 635 finally { 636 if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); } 637 } 638 dbg.location(306, 5); 639 640 } 641 finally { 642 dbg.exitRule(getGrammarFileName(), "compilationUnit"); 643 decRuleLevel(); 644 if ( getRuleLevel()==0 ) {dbg.terminate();} 645 } 646 647 return ; 648 } 649 // $ANTLR end "compilationUnit" 650 651 652 // $ANTLR start "packageDeclaration" 653 // src/com/google/doclava/parser/Java.g:308:1: packageDeclaration : 'package' qualifiedName ';' ; packageDeclaration()654 public final void packageDeclaration() throws RecognitionException { 655 int packageDeclaration_StartIndex = input.index(); 656 try { dbg.enterRule(getGrammarFileName(), "packageDeclaration"); 657 if ( getRuleLevel()==0 ) {dbg.commence();} 658 incRuleLevel(); 659 dbg.location(308, 1); 660 661 try { 662 if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; } 663 // src/com/google/doclava/parser/Java.g:309:5: ( 'package' qualifiedName ';' ) 664 dbg.enterAlt(1); 665 666 // src/com/google/doclava/parser/Java.g:309:9: 'package' qualifiedName ';' 667 { 668 dbg.location(309,9); 669 match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration167); if (state.failed) return ; 670 dbg.location(309,19); 671 pushFollow(FOLLOW_qualifiedName_in_packageDeclaration169); 672 qualifiedName(); 673 674 state._fsp--; 675 if (state.failed) return ; 676 dbg.location(310,9); 677 match(input,SEMI,FOLLOW_SEMI_in_packageDeclaration179); if (state.failed) return ; 678 679 } 680 681 } 682 catch (RecognitionException re) { 683 reportError(re); 684 recover(input,re); 685 } 686 finally { 687 if ( state.backtracking>0 ) { memoize(input, 2, packageDeclaration_StartIndex); } 688 } 689 dbg.location(311, 5); 690 691 } 692 finally { 693 dbg.exitRule(getGrammarFileName(), "packageDeclaration"); 694 decRuleLevel(); 695 if ( getRuleLevel()==0 ) {dbg.terminate();} 696 } 697 698 return ; 699 } 700 // $ANTLR end "packageDeclaration" 701 702 703 // $ANTLR start "importDeclaration" 704 // src/com/google/doclava/parser/Java.g:313:1: importDeclaration : ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' ); importDeclaration()705 public final void importDeclaration() throws RecognitionException { 706 int importDeclaration_StartIndex = input.index(); 707 try { dbg.enterRule(getGrammarFileName(), "importDeclaration"); 708 if ( getRuleLevel()==0 ) {dbg.commence();} 709 incRuleLevel(); 710 dbg.location(313, 1); 711 712 try { 713 if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; } 714 // src/com/google/doclava/parser/Java.g:314:5: ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' ) 715 int alt9=2; 716 try { dbg.enterDecision(9, decisionCanBacktrack[9]); 717 718 int LA9_0 = input.LA(1); 719 720 if ( (LA9_0==IMPORT) ) { 721 int LA9_1 = input.LA(2); 722 723 if ( (LA9_1==STATIC) ) { 724 int LA9_2 = input.LA(3); 725 726 if ( (LA9_2==IDENTIFIER) ) { 727 int LA9_3 = input.LA(4); 728 729 if ( (LA9_3==DOT) ) { 730 int LA9_4 = input.LA(5); 731 732 if ( (LA9_4==STAR) ) { 733 alt9=1; 734 } 735 else if ( (LA9_4==IDENTIFIER) ) { 736 alt9=2; 737 } 738 else { 739 if (state.backtracking>0) {state.failed=true; return ;} 740 NoViableAltException nvae = 741 new NoViableAltException("", 9, 4, input); 742 743 dbg.recognitionException(nvae); 744 throw nvae; 745 } 746 } 747 else { 748 if (state.backtracking>0) {state.failed=true; return ;} 749 NoViableAltException nvae = 750 new NoViableAltException("", 9, 3, input); 751 752 dbg.recognitionException(nvae); 753 throw nvae; 754 } 755 } 756 else { 757 if (state.backtracking>0) {state.failed=true; return ;} 758 NoViableAltException nvae = 759 new NoViableAltException("", 9, 2, input); 760 761 dbg.recognitionException(nvae); 762 throw nvae; 763 } 764 } 765 else if ( (LA9_1==IDENTIFIER) ) { 766 int LA9_3 = input.LA(3); 767 768 if ( (LA9_3==DOT) ) { 769 int LA9_4 = input.LA(4); 770 771 if ( (LA9_4==STAR) ) { 772 alt9=1; 773 } 774 else if ( (LA9_4==IDENTIFIER) ) { 775 alt9=2; 776 } 777 else { 778 if (state.backtracking>0) {state.failed=true; return ;} 779 NoViableAltException nvae = 780 new NoViableAltException("", 9, 4, input); 781 782 dbg.recognitionException(nvae); 783 throw nvae; 784 } 785 } 786 else { 787 if (state.backtracking>0) {state.failed=true; return ;} 788 NoViableAltException nvae = 789 new NoViableAltException("", 9, 3, input); 790 791 dbg.recognitionException(nvae); 792 throw nvae; 793 } 794 } 795 else { 796 if (state.backtracking>0) {state.failed=true; return ;} 797 NoViableAltException nvae = 798 new NoViableAltException("", 9, 1, input); 799 800 dbg.recognitionException(nvae); 801 throw nvae; 802 } 803 } 804 else { 805 if (state.backtracking>0) {state.failed=true; return ;} 806 NoViableAltException nvae = 807 new NoViableAltException("", 9, 0, input); 808 809 dbg.recognitionException(nvae); 810 throw nvae; 811 } 812 } finally {dbg.exitDecision(9);} 813 814 switch (alt9) { 815 case 1 : 816 dbg.enterAlt(1); 817 818 // src/com/google/doclava/parser/Java.g:314:9: 'import' ( 'static' )? IDENTIFIER '.' '*' ';' 819 { 820 dbg.location(314,9); 821 match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration198); if (state.failed) return ; 822 dbg.location(315,9); 823 // src/com/google/doclava/parser/Java.g:315:9: ( 'static' )? 824 int alt5=2; 825 try { dbg.enterSubRule(5); 826 try { dbg.enterDecision(5, decisionCanBacktrack[5]); 827 828 int LA5_0 = input.LA(1); 829 830 if ( (LA5_0==STATIC) ) { 831 alt5=1; 832 } 833 } finally {dbg.exitDecision(5);} 834 835 switch (alt5) { 836 case 1 : 837 dbg.enterAlt(1); 838 839 // src/com/google/doclava/parser/Java.g:315:10: 'static' 840 { 841 dbg.location(315,10); 842 match(input,STATIC,FOLLOW_STATIC_in_importDeclaration209); if (state.failed) return ; 843 844 } 845 break; 846 847 } 848 } finally {dbg.exitSubRule(5);} 849 850 dbg.location(317,9); 851 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration230); if (state.failed) return ; 852 dbg.location(317,20); 853 match(input,DOT,FOLLOW_DOT_in_importDeclaration232); if (state.failed) return ; 854 dbg.location(317,24); 855 match(input,STAR,FOLLOW_STAR_in_importDeclaration234); if (state.failed) return ; 856 dbg.location(318,9); 857 match(input,SEMI,FOLLOW_SEMI_in_importDeclaration244); if (state.failed) return ; 858 859 } 860 break; 861 case 2 : 862 dbg.enterAlt(2); 863 864 // src/com/google/doclava/parser/Java.g:319:9: 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' 865 { 866 dbg.location(319,9); 867 match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration254); if (state.failed) return ; 868 dbg.location(320,9); 869 // src/com/google/doclava/parser/Java.g:320:9: ( 'static' )? 870 int alt6=2; 871 try { dbg.enterSubRule(6); 872 try { dbg.enterDecision(6, decisionCanBacktrack[6]); 873 874 int LA6_0 = input.LA(1); 875 876 if ( (LA6_0==STATIC) ) { 877 alt6=1; 878 } 879 } finally {dbg.exitDecision(6);} 880 881 switch (alt6) { 882 case 1 : 883 dbg.enterAlt(1); 884 885 // src/com/google/doclava/parser/Java.g:320:10: 'static' 886 { 887 dbg.location(320,10); 888 match(input,STATIC,FOLLOW_STATIC_in_importDeclaration265); if (state.failed) return ; 889 890 } 891 break; 892 893 } 894 } finally {dbg.exitSubRule(6);} 895 896 dbg.location(322,9); 897 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration286); if (state.failed) return ; 898 dbg.location(323,9); 899 // src/com/google/doclava/parser/Java.g:323:9: ( '.' IDENTIFIER )+ 900 int cnt7=0; 901 try { dbg.enterSubRule(7); 902 903 loop7: 904 do { 905 int alt7=2; 906 try { dbg.enterDecision(7, decisionCanBacktrack[7]); 907 908 int LA7_0 = input.LA(1); 909 910 if ( (LA7_0==DOT) ) { 911 int LA7_1 = input.LA(2); 912 913 if ( (LA7_1==IDENTIFIER) ) { 914 alt7=1; 915 } 916 917 918 } 919 920 921 } finally {dbg.exitDecision(7);} 922 923 switch (alt7) { 924 case 1 : 925 dbg.enterAlt(1); 926 927 // src/com/google/doclava/parser/Java.g:323:10: '.' IDENTIFIER 928 { 929 dbg.location(323,10); 930 match(input,DOT,FOLLOW_DOT_in_importDeclaration297); if (state.failed) return ; 931 dbg.location(323,14); 932 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration299); if (state.failed) return ; 933 934 } 935 break; 936 937 default : 938 if ( cnt7 >= 1 ) break loop7; 939 if (state.backtracking>0) {state.failed=true; return ;} 940 EarlyExitException eee = 941 new EarlyExitException(7, input); 942 dbg.recognitionException(eee); 943 944 throw eee; 945 } 946 cnt7++; 947 } while (true); 948 } finally {dbg.exitSubRule(7);} 949 950 dbg.location(325,9); 951 // src/com/google/doclava/parser/Java.g:325:9: ( '.' '*' )? 952 int alt8=2; 953 try { dbg.enterSubRule(8); 954 try { dbg.enterDecision(8, decisionCanBacktrack[8]); 955 956 int LA8_0 = input.LA(1); 957 958 if ( (LA8_0==DOT) ) { 959 alt8=1; 960 } 961 } finally {dbg.exitDecision(8);} 962 963 switch (alt8) { 964 case 1 : 965 dbg.enterAlt(1); 966 967 // src/com/google/doclava/parser/Java.g:325:10: '.' '*' 968 { 969 dbg.location(325,10); 970 match(input,DOT,FOLLOW_DOT_in_importDeclaration321); if (state.failed) return ; 971 dbg.location(325,14); 972 match(input,STAR,FOLLOW_STAR_in_importDeclaration323); if (state.failed) return ; 973 974 } 975 break; 976 977 } 978 } finally {dbg.exitSubRule(8);} 979 980 dbg.location(327,9); 981 match(input,SEMI,FOLLOW_SEMI_in_importDeclaration344); if (state.failed) return ; 982 983 } 984 break; 985 986 } 987 } 988 catch (RecognitionException re) { 989 reportError(re); 990 recover(input,re); 991 } 992 finally { 993 if ( state.backtracking>0 ) { memoize(input, 3, importDeclaration_StartIndex); } 994 } 995 dbg.location(328, 5); 996 997 } 998 finally { 999 dbg.exitRule(getGrammarFileName(), "importDeclaration"); 1000 decRuleLevel(); 1001 if ( getRuleLevel()==0 ) {dbg.terminate();} 1002 } 1003 1004 return ; 1005 } 1006 // $ANTLR end "importDeclaration" 1007 1008 1009 // $ANTLR start "qualifiedImportName" 1010 // src/com/google/doclava/parser/Java.g:330:1: qualifiedImportName : IDENTIFIER ( '.' IDENTIFIER )* ; qualifiedImportName()1011 public final void qualifiedImportName() throws RecognitionException { 1012 int qualifiedImportName_StartIndex = input.index(); 1013 try { dbg.enterRule(getGrammarFileName(), "qualifiedImportName"); 1014 if ( getRuleLevel()==0 ) {dbg.commence();} 1015 incRuleLevel(); 1016 dbg.location(330, 1); 1017 1018 try { 1019 if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; } 1020 // src/com/google/doclava/parser/Java.g:331:5: ( IDENTIFIER ( '.' IDENTIFIER )* ) 1021 dbg.enterAlt(1); 1022 1023 // src/com/google/doclava/parser/Java.g:331:9: IDENTIFIER ( '.' IDENTIFIER )* 1024 { 1025 dbg.location(331,9); 1026 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName363); if (state.failed) return ; 1027 dbg.location(332,9); 1028 // src/com/google/doclava/parser/Java.g:332:9: ( '.' IDENTIFIER )* 1029 try { dbg.enterSubRule(10); 1030 1031 loop10: 1032 do { 1033 int alt10=2; 1034 try { dbg.enterDecision(10, decisionCanBacktrack[10]); 1035 1036 int LA10_0 = input.LA(1); 1037 1038 if ( (LA10_0==DOT) ) { 1039 alt10=1; 1040 } 1041 1042 1043 } finally {dbg.exitDecision(10);} 1044 1045 switch (alt10) { 1046 case 1 : 1047 dbg.enterAlt(1); 1048 1049 // src/com/google/doclava/parser/Java.g:332:10: '.' IDENTIFIER 1050 { 1051 dbg.location(332,10); 1052 match(input,DOT,FOLLOW_DOT_in_qualifiedImportName374); if (state.failed) return ; 1053 dbg.location(332,14); 1054 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName376); if (state.failed) return ; 1055 1056 } 1057 break; 1058 1059 default : 1060 break loop10; 1061 } 1062 } while (true); 1063 } finally {dbg.exitSubRule(10);} 1064 1065 1066 } 1067 1068 } 1069 catch (RecognitionException re) { 1070 reportError(re); 1071 recover(input,re); 1072 } 1073 finally { 1074 if ( state.backtracking>0 ) { memoize(input, 4, qualifiedImportName_StartIndex); } 1075 } 1076 dbg.location(334, 5); 1077 1078 } 1079 finally { 1080 dbg.exitRule(getGrammarFileName(), "qualifiedImportName"); 1081 decRuleLevel(); 1082 if ( getRuleLevel()==0 ) {dbg.terminate();} 1083 } 1084 1085 return ; 1086 } 1087 // $ANTLR end "qualifiedImportName" 1088 1089 1090 // $ANTLR start "typeDeclaration" 1091 // src/com/google/doclava/parser/Java.g:336:1: typeDeclaration : ( classOrInterfaceDeclaration | ';' ); typeDeclaration()1092 public final void typeDeclaration() throws RecognitionException { 1093 int typeDeclaration_StartIndex = input.index(); 1094 try { dbg.enterRule(getGrammarFileName(), "typeDeclaration"); 1095 if ( getRuleLevel()==0 ) {dbg.commence();} 1096 incRuleLevel(); 1097 dbg.location(336, 1); 1098 1099 try { 1100 if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; } 1101 // src/com/google/doclava/parser/Java.g:337:5: ( classOrInterfaceDeclaration | ';' ) 1102 int alt11=2; 1103 try { dbg.enterDecision(11, decisionCanBacktrack[11]); 1104 1105 int LA11_0 = input.LA(1); 1106 1107 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) ) { 1108 alt11=1; 1109 } 1110 else if ( (LA11_0==SEMI) ) { 1111 alt11=2; 1112 } 1113 else { 1114 if (state.backtracking>0) {state.failed=true; return ;} 1115 NoViableAltException nvae = 1116 new NoViableAltException("", 11, 0, input); 1117 1118 dbg.recognitionException(nvae); 1119 throw nvae; 1120 } 1121 } finally {dbg.exitDecision(11);} 1122 1123 switch (alt11) { 1124 case 1 : 1125 dbg.enterAlt(1); 1126 1127 // src/com/google/doclava/parser/Java.g:337:9: classOrInterfaceDeclaration 1128 { 1129 dbg.location(337,9); 1130 pushFollow(FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406); 1131 classOrInterfaceDeclaration(); 1132 1133 state._fsp--; 1134 if (state.failed) return ; 1135 1136 } 1137 break; 1138 case 2 : 1139 dbg.enterAlt(2); 1140 1141 // src/com/google/doclava/parser/Java.g:338:9: ';' 1142 { 1143 dbg.location(338,9); 1144 match(input,SEMI,FOLLOW_SEMI_in_typeDeclaration416); if (state.failed) return ; 1145 1146 } 1147 break; 1148 1149 } 1150 } 1151 catch (RecognitionException re) { 1152 reportError(re); 1153 recover(input,re); 1154 } 1155 finally { 1156 if ( state.backtracking>0 ) { memoize(input, 5, typeDeclaration_StartIndex); } 1157 } 1158 dbg.location(339, 5); 1159 1160 } 1161 finally { 1162 dbg.exitRule(getGrammarFileName(), "typeDeclaration"); 1163 decRuleLevel(); 1164 if ( getRuleLevel()==0 ) {dbg.terminate();} 1165 } 1166 1167 return ; 1168 } 1169 // $ANTLR end "typeDeclaration" 1170 1171 1172 // $ANTLR start "classOrInterfaceDeclaration" 1173 // src/com/google/doclava/parser/Java.g:341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration ); classOrInterfaceDeclaration()1174 public final void classOrInterfaceDeclaration() throws RecognitionException { 1175 int classOrInterfaceDeclaration_StartIndex = input.index(); 1176 try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceDeclaration"); 1177 if ( getRuleLevel()==0 ) {dbg.commence();} 1178 incRuleLevel(); 1179 dbg.location(341, 1); 1180 1181 try { 1182 if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; } 1183 // src/com/google/doclava/parser/Java.g:342:5: ( classDeclaration | interfaceDeclaration ) 1184 int alt12=2; 1185 try { dbg.enterDecision(12, decisionCanBacktrack[12]); 1186 1187 try { 1188 isCyclicDecision = true; 1189 alt12 = dfa12.predict(input); 1190 } 1191 catch (NoViableAltException nvae) { 1192 dbg.recognitionException(nvae); 1193 throw nvae; 1194 } 1195 } finally {dbg.exitDecision(12);} 1196 1197 switch (alt12) { 1198 case 1 : 1199 dbg.enterAlt(1); 1200 1201 // src/com/google/doclava/parser/Java.g:342:10: classDeclaration 1202 { 1203 dbg.location(342,10); 1204 pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436); 1205 classDeclaration(); 1206 1207 state._fsp--; 1208 if (state.failed) return ; 1209 1210 } 1211 break; 1212 case 2 : 1213 dbg.enterAlt(2); 1214 1215 // src/com/google/doclava/parser/Java.g:343:9: interfaceDeclaration 1216 { 1217 dbg.location(343,9); 1218 pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446); 1219 interfaceDeclaration(); 1220 1221 state._fsp--; 1222 if (state.failed) return ; 1223 1224 } 1225 break; 1226 1227 } 1228 } 1229 catch (RecognitionException re) { 1230 reportError(re); 1231 recover(input,re); 1232 } 1233 finally { 1234 if ( state.backtracking>0 ) { memoize(input, 6, classOrInterfaceDeclaration_StartIndex); } 1235 } 1236 dbg.location(344, 5); 1237 1238 } 1239 finally { 1240 dbg.exitRule(getGrammarFileName(), "classOrInterfaceDeclaration"); 1241 decRuleLevel(); 1242 if ( getRuleLevel()==0 ) {dbg.terminate();} 1243 } 1244 1245 return ; 1246 } 1247 // $ANTLR end "classOrInterfaceDeclaration" 1248 1249 1250 // $ANTLR start "modifiers" 1251 // src/com/google/doclava/parser/Java.g:347:1: modifiers : ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ; modifiers()1252 public final void modifiers() throws RecognitionException { 1253 int modifiers_StartIndex = input.index(); 1254 try { dbg.enterRule(getGrammarFileName(), "modifiers"); 1255 if ( getRuleLevel()==0 ) {dbg.commence();} 1256 incRuleLevel(); 1257 dbg.location(347, 1); 1258 1259 try { 1260 if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; } 1261 // src/com/google/doclava/parser/Java.g:348:5: ( ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ) 1262 dbg.enterAlt(1); 1263 1264 // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* 1265 { 1266 dbg.location(349,5); 1267 // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* 1268 try { dbg.enterSubRule(13); 1269 1270 loop13: 1271 do { 1272 int alt13=13; 1273 try { dbg.enterDecision(13, decisionCanBacktrack[13]); 1274 1275 try { 1276 isCyclicDecision = true; 1277 alt13 = dfa13.predict(input); 1278 } 1279 catch (NoViableAltException nvae) { 1280 dbg.recognitionException(nvae); 1281 throw nvae; 1282 } 1283 } finally {dbg.exitDecision(13);} 1284 1285 switch (alt13) { 1286 case 1 : 1287 dbg.enterAlt(1); 1288 1289 // src/com/google/doclava/parser/Java.g:349:10: annotation 1290 { 1291 dbg.location(349,10); 1292 pushFollow(FOLLOW_annotation_in_modifiers473); 1293 annotation(); 1294 1295 state._fsp--; 1296 if (state.failed) return ; 1297 1298 } 1299 break; 1300 case 2 : 1301 dbg.enterAlt(2); 1302 1303 // src/com/google/doclava/parser/Java.g:350:9: 'public' 1304 { 1305 dbg.location(350,9); 1306 match(input,PUBLIC,FOLLOW_PUBLIC_in_modifiers483); if (state.failed) return ; 1307 1308 } 1309 break; 1310 case 3 : 1311 dbg.enterAlt(3); 1312 1313 // src/com/google/doclava/parser/Java.g:351:9: 'protected' 1314 { 1315 dbg.location(351,9); 1316 match(input,PROTECTED,FOLLOW_PROTECTED_in_modifiers493); if (state.failed) return ; 1317 1318 } 1319 break; 1320 case 4 : 1321 dbg.enterAlt(4); 1322 1323 // src/com/google/doclava/parser/Java.g:352:9: 'private' 1324 { 1325 dbg.location(352,9); 1326 match(input,PRIVATE,FOLLOW_PRIVATE_in_modifiers503); if (state.failed) return ; 1327 1328 } 1329 break; 1330 case 5 : 1331 dbg.enterAlt(5); 1332 1333 // src/com/google/doclava/parser/Java.g:353:9: 'static' 1334 { 1335 dbg.location(353,9); 1336 match(input,STATIC,FOLLOW_STATIC_in_modifiers513); if (state.failed) return ; 1337 1338 } 1339 break; 1340 case 6 : 1341 dbg.enterAlt(6); 1342 1343 // src/com/google/doclava/parser/Java.g:354:9: 'abstract' 1344 { 1345 dbg.location(354,9); 1346 match(input,ABSTRACT,FOLLOW_ABSTRACT_in_modifiers523); if (state.failed) return ; 1347 1348 } 1349 break; 1350 case 7 : 1351 dbg.enterAlt(7); 1352 1353 // src/com/google/doclava/parser/Java.g:355:9: 'final' 1354 { 1355 dbg.location(355,9); 1356 match(input,FINAL,FOLLOW_FINAL_in_modifiers533); if (state.failed) return ; 1357 1358 } 1359 break; 1360 case 8 : 1361 dbg.enterAlt(8); 1362 1363 // src/com/google/doclava/parser/Java.g:356:9: 'native' 1364 { 1365 dbg.location(356,9); 1366 match(input,NATIVE,FOLLOW_NATIVE_in_modifiers543); if (state.failed) return ; 1367 1368 } 1369 break; 1370 case 9 : 1371 dbg.enterAlt(9); 1372 1373 // src/com/google/doclava/parser/Java.g:357:9: 'synchronized' 1374 { 1375 dbg.location(357,9); 1376 match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_modifiers553); if (state.failed) return ; 1377 1378 } 1379 break; 1380 case 10 : 1381 dbg.enterAlt(10); 1382 1383 // src/com/google/doclava/parser/Java.g:358:9: 'transient' 1384 { 1385 dbg.location(358,9); 1386 match(input,TRANSIENT,FOLLOW_TRANSIENT_in_modifiers563); if (state.failed) return ; 1387 1388 } 1389 break; 1390 case 11 : 1391 dbg.enterAlt(11); 1392 1393 // src/com/google/doclava/parser/Java.g:359:9: 'volatile' 1394 { 1395 dbg.location(359,9); 1396 match(input,VOLATILE,FOLLOW_VOLATILE_in_modifiers573); if (state.failed) return ; 1397 1398 } 1399 break; 1400 case 12 : 1401 dbg.enterAlt(12); 1402 1403 // src/com/google/doclava/parser/Java.g:360:9: 'strictfp' 1404 { 1405 dbg.location(360,9); 1406 match(input,STRICTFP,FOLLOW_STRICTFP_in_modifiers583); if (state.failed) return ; 1407 1408 } 1409 break; 1410 1411 default : 1412 break loop13; 1413 } 1414 } while (true); 1415 } finally {dbg.exitSubRule(13);} 1416 1417 1418 } 1419 1420 } 1421 catch (RecognitionException re) { 1422 reportError(re); 1423 recover(input,re); 1424 } 1425 finally { 1426 if ( state.backtracking>0 ) { memoize(input, 7, modifiers_StartIndex); } 1427 } 1428 dbg.location(362, 5); 1429 1430 } 1431 finally { 1432 dbg.exitRule(getGrammarFileName(), "modifiers"); 1433 decRuleLevel(); 1434 if ( getRuleLevel()==0 ) {dbg.terminate();} 1435 } 1436 1437 return ; 1438 } 1439 // $ANTLR end "modifiers" 1440 1441 1442 // $ANTLR start "variableModifiers" 1443 // src/com/google/doclava/parser/Java.g:365:1: variableModifiers : ( 'final' | annotation )* ; variableModifiers()1444 public final void variableModifiers() throws RecognitionException { 1445 int variableModifiers_StartIndex = input.index(); 1446 try { dbg.enterRule(getGrammarFileName(), "variableModifiers"); 1447 if ( getRuleLevel()==0 ) {dbg.commence();} 1448 incRuleLevel(); 1449 dbg.location(365, 1); 1450 1451 try { 1452 if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; } 1453 // src/com/google/doclava/parser/Java.g:366:5: ( ( 'final' | annotation )* ) 1454 dbg.enterAlt(1); 1455 1456 // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )* 1457 { 1458 dbg.location(366,9); 1459 // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )* 1460 try { dbg.enterSubRule(14); 1461 1462 loop14: 1463 do { 1464 int alt14=3; 1465 try { dbg.enterDecision(14, decisionCanBacktrack[14]); 1466 1467 int LA14_0 = input.LA(1); 1468 1469 if ( (LA14_0==FINAL) ) { 1470 alt14=1; 1471 } 1472 else if ( (LA14_0==MONKEYS_AT) ) { 1473 alt14=2; 1474 } 1475 1476 1477 } finally {dbg.exitDecision(14);} 1478 1479 switch (alt14) { 1480 case 1 : 1481 dbg.enterAlt(1); 1482 1483 // src/com/google/doclava/parser/Java.g:366:13: 'final' 1484 { 1485 dbg.location(366,13); 1486 match(input,FINAL,FOLLOW_FINAL_in_variableModifiers614); if (state.failed) return ; 1487 1488 } 1489 break; 1490 case 2 : 1491 dbg.enterAlt(2); 1492 1493 // src/com/google/doclava/parser/Java.g:367:13: annotation 1494 { 1495 dbg.location(367,13); 1496 pushFollow(FOLLOW_annotation_in_variableModifiers628); 1497 annotation(); 1498 1499 state._fsp--; 1500 if (state.failed) return ; 1501 1502 } 1503 break; 1504 1505 default : 1506 break loop14; 1507 } 1508 } while (true); 1509 } finally {dbg.exitSubRule(14);} 1510 1511 1512 } 1513 1514 } 1515 catch (RecognitionException re) { 1516 reportError(re); 1517 recover(input,re); 1518 } 1519 finally { 1520 if ( state.backtracking>0 ) { memoize(input, 8, variableModifiers_StartIndex); } 1521 } 1522 dbg.location(369, 5); 1523 1524 } 1525 finally { 1526 dbg.exitRule(getGrammarFileName(), "variableModifiers"); 1527 decRuleLevel(); 1528 if ( getRuleLevel()==0 ) {dbg.terminate();} 1529 } 1530 1531 return ; 1532 } 1533 // $ANTLR end "variableModifiers" 1534 1535 1536 // $ANTLR start "classDeclaration" 1537 // src/com/google/doclava/parser/Java.g:372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration ); classDeclaration()1538 public final void classDeclaration() throws RecognitionException { 1539 int classDeclaration_StartIndex = input.index(); 1540 try { dbg.enterRule(getGrammarFileName(), "classDeclaration"); 1541 if ( getRuleLevel()==0 ) {dbg.commence();} 1542 incRuleLevel(); 1543 dbg.location(372, 1); 1544 1545 try { 1546 if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; } 1547 // src/com/google/doclava/parser/Java.g:373:5: ( normalClassDeclaration | enumDeclaration ) 1548 int alt15=2; 1549 try { dbg.enterDecision(15, decisionCanBacktrack[15]); 1550 1551 try { 1552 isCyclicDecision = true; 1553 alt15 = dfa15.predict(input); 1554 } 1555 catch (NoViableAltException nvae) { 1556 dbg.recognitionException(nvae); 1557 throw nvae; 1558 } 1559 } finally {dbg.exitDecision(15);} 1560 1561 switch (alt15) { 1562 case 1 : 1563 dbg.enterAlt(1); 1564 1565 // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration 1566 { 1567 dbg.location(373,9); 1568 pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration659); 1569 normalClassDeclaration(); 1570 1571 state._fsp--; 1572 if (state.failed) return ; 1573 1574 } 1575 break; 1576 case 2 : 1577 dbg.enterAlt(2); 1578 1579 // src/com/google/doclava/parser/Java.g:374:9: enumDeclaration 1580 { 1581 dbg.location(374,9); 1582 pushFollow(FOLLOW_enumDeclaration_in_classDeclaration669); 1583 enumDeclaration(); 1584 1585 state._fsp--; 1586 if (state.failed) return ; 1587 1588 } 1589 break; 1590 1591 } 1592 } 1593 catch (RecognitionException re) { 1594 reportError(re); 1595 recover(input,re); 1596 } 1597 finally { 1598 if ( state.backtracking>0 ) { memoize(input, 9, classDeclaration_StartIndex); } 1599 } 1600 dbg.location(375, 5); 1601 1602 } 1603 finally { 1604 dbg.exitRule(getGrammarFileName(), "classDeclaration"); 1605 decRuleLevel(); 1606 if ( getRuleLevel()==0 ) {dbg.terminate();} 1607 } 1608 1609 return ; 1610 } 1611 // $ANTLR end "classDeclaration" 1612 1613 1614 // $ANTLR start "normalClassDeclaration" 1615 // src/com/google/doclava/parser/Java.g:377:1: normalClassDeclaration : modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody ; normalClassDeclaration()1616 public final void normalClassDeclaration() throws RecognitionException { 1617 int normalClassDeclaration_StartIndex = input.index(); 1618 try { dbg.enterRule(getGrammarFileName(), "normalClassDeclaration"); 1619 if ( getRuleLevel()==0 ) {dbg.commence();} 1620 incRuleLevel(); 1621 dbg.location(377, 1); 1622 1623 try { 1624 if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; } 1625 // src/com/google/doclava/parser/Java.g:378:5: ( modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody ) 1626 dbg.enterAlt(1); 1627 1628 // src/com/google/doclava/parser/Java.g:378:9: modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody 1629 { 1630 dbg.location(378,9); 1631 pushFollow(FOLLOW_modifiers_in_normalClassDeclaration688); 1632 modifiers(); 1633 1634 state._fsp--; 1635 if (state.failed) return ; 1636 dbg.location(378,20); 1637 match(input,CLASS,FOLLOW_CLASS_in_normalClassDeclaration691); if (state.failed) return ; 1638 dbg.location(378,28); 1639 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalClassDeclaration693); if (state.failed) return ; 1640 dbg.location(379,9); 1641 // src/com/google/doclava/parser/Java.g:379:9: ( typeParameters )? 1642 int alt16=2; 1643 try { dbg.enterSubRule(16); 1644 try { dbg.enterDecision(16, decisionCanBacktrack[16]); 1645 1646 int LA16_0 = input.LA(1); 1647 1648 if ( (LA16_0==LT) ) { 1649 alt16=1; 1650 } 1651 } finally {dbg.exitDecision(16);} 1652 1653 switch (alt16) { 1654 case 1 : 1655 dbg.enterAlt(1); 1656 1657 // src/com/google/doclava/parser/Java.g:379:10: typeParameters 1658 { 1659 dbg.location(379,10); 1660 pushFollow(FOLLOW_typeParameters_in_normalClassDeclaration704); 1661 typeParameters(); 1662 1663 state._fsp--; 1664 if (state.failed) return ; 1665 1666 } 1667 break; 1668 1669 } 1670 } finally {dbg.exitSubRule(16);} 1671 1672 dbg.location(381,9); 1673 // src/com/google/doclava/parser/Java.g:381:9: ( 'extends' type )? 1674 int alt17=2; 1675 try { dbg.enterSubRule(17); 1676 try { dbg.enterDecision(17, decisionCanBacktrack[17]); 1677 1678 int LA17_0 = input.LA(1); 1679 1680 if ( (LA17_0==EXTENDS) ) { 1681 alt17=1; 1682 } 1683 } finally {dbg.exitDecision(17);} 1684 1685 switch (alt17) { 1686 case 1 : 1687 dbg.enterAlt(1); 1688 1689 // src/com/google/doclava/parser/Java.g:381:10: 'extends' type 1690 { 1691 dbg.location(381,10); 1692 match(input,EXTENDS,FOLLOW_EXTENDS_in_normalClassDeclaration726); if (state.failed) return ; 1693 dbg.location(381,20); 1694 pushFollow(FOLLOW_type_in_normalClassDeclaration728); 1695 type(); 1696 1697 state._fsp--; 1698 if (state.failed) return ; 1699 1700 } 1701 break; 1702 1703 } 1704 } finally {dbg.exitSubRule(17);} 1705 1706 dbg.location(383,9); 1707 // src/com/google/doclava/parser/Java.g:383:9: ( 'implements' typeList )? 1708 int alt18=2; 1709 try { dbg.enterSubRule(18); 1710 try { dbg.enterDecision(18, decisionCanBacktrack[18]); 1711 1712 int LA18_0 = input.LA(1); 1713 1714 if ( (LA18_0==IMPLEMENTS) ) { 1715 alt18=1; 1716 } 1717 } finally {dbg.exitDecision(18);} 1718 1719 switch (alt18) { 1720 case 1 : 1721 dbg.enterAlt(1); 1722 1723 // src/com/google/doclava/parser/Java.g:383:10: 'implements' typeList 1724 { 1725 dbg.location(383,10); 1726 match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_normalClassDeclaration750); if (state.failed) return ; 1727 dbg.location(383,23); 1728 pushFollow(FOLLOW_typeList_in_normalClassDeclaration752); 1729 typeList(); 1730 1731 state._fsp--; 1732 if (state.failed) return ; 1733 1734 } 1735 break; 1736 1737 } 1738 } finally {dbg.exitSubRule(18);} 1739 1740 dbg.location(385,9); 1741 pushFollow(FOLLOW_classBody_in_normalClassDeclaration773); 1742 classBody(); 1743 1744 state._fsp--; 1745 if (state.failed) return ; 1746 1747 } 1748 1749 } 1750 catch (RecognitionException re) { 1751 reportError(re); 1752 recover(input,re); 1753 } 1754 finally { 1755 if ( state.backtracking>0 ) { memoize(input, 10, normalClassDeclaration_StartIndex); } 1756 } 1757 dbg.location(386, 5); 1758 1759 } 1760 finally { 1761 dbg.exitRule(getGrammarFileName(), "normalClassDeclaration"); 1762 decRuleLevel(); 1763 if ( getRuleLevel()==0 ) {dbg.terminate();} 1764 } 1765 1766 return ; 1767 } 1768 // $ANTLR end "normalClassDeclaration" 1769 1770 1771 // $ANTLR start "typeParameters" 1772 // src/com/google/doclava/parser/Java.g:389:1: typeParameters : '<' typeParameter ( ',' typeParameter )* '>' ; typeParameters()1773 public final void typeParameters() throws RecognitionException { 1774 int typeParameters_StartIndex = input.index(); 1775 try { dbg.enterRule(getGrammarFileName(), "typeParameters"); 1776 if ( getRuleLevel()==0 ) {dbg.commence();} 1777 incRuleLevel(); 1778 dbg.location(389, 1); 1779 1780 try { 1781 if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; } 1782 // src/com/google/doclava/parser/Java.g:390:5: ( '<' typeParameter ( ',' typeParameter )* '>' ) 1783 dbg.enterAlt(1); 1784 1785 // src/com/google/doclava/parser/Java.g:390:9: '<' typeParameter ( ',' typeParameter )* '>' 1786 { 1787 dbg.location(390,9); 1788 match(input,LT,FOLLOW_LT_in_typeParameters793); if (state.failed) return ; 1789 dbg.location(391,13); 1790 pushFollow(FOLLOW_typeParameter_in_typeParameters807); 1791 typeParameter(); 1792 1793 state._fsp--; 1794 if (state.failed) return ; 1795 dbg.location(392,13); 1796 // src/com/google/doclava/parser/Java.g:392:13: ( ',' typeParameter )* 1797 try { dbg.enterSubRule(19); 1798 1799 loop19: 1800 do { 1801 int alt19=2; 1802 try { dbg.enterDecision(19, decisionCanBacktrack[19]); 1803 1804 int LA19_0 = input.LA(1); 1805 1806 if ( (LA19_0==COMMA) ) { 1807 alt19=1; 1808 } 1809 1810 1811 } finally {dbg.exitDecision(19);} 1812 1813 switch (alt19) { 1814 case 1 : 1815 dbg.enterAlt(1); 1816 1817 // src/com/google/doclava/parser/Java.g:392:14: ',' typeParameter 1818 { 1819 dbg.location(392,14); 1820 match(input,COMMA,FOLLOW_COMMA_in_typeParameters822); if (state.failed) return ; 1821 dbg.location(392,18); 1822 pushFollow(FOLLOW_typeParameter_in_typeParameters824); 1823 typeParameter(); 1824 1825 state._fsp--; 1826 if (state.failed) return ; 1827 1828 } 1829 break; 1830 1831 default : 1832 break loop19; 1833 } 1834 } while (true); 1835 } finally {dbg.exitSubRule(19);} 1836 1837 dbg.location(394,9); 1838 match(input,GT,FOLLOW_GT_in_typeParameters849); if (state.failed) return ; 1839 1840 } 1841 1842 } 1843 catch (RecognitionException re) { 1844 reportError(re); 1845 recover(input,re); 1846 } 1847 finally { 1848 if ( state.backtracking>0 ) { memoize(input, 11, typeParameters_StartIndex); } 1849 } 1850 dbg.location(395, 5); 1851 1852 } 1853 finally { 1854 dbg.exitRule(getGrammarFileName(), "typeParameters"); 1855 decRuleLevel(); 1856 if ( getRuleLevel()==0 ) {dbg.terminate();} 1857 } 1858 1859 return ; 1860 } 1861 // $ANTLR end "typeParameters" 1862 1863 1864 // $ANTLR start "typeParameter" 1865 // src/com/google/doclava/parser/Java.g:397:1: typeParameter : IDENTIFIER ( 'extends' typeBound )? ; typeParameter()1866 public final void typeParameter() throws RecognitionException { 1867 int typeParameter_StartIndex = input.index(); 1868 try { dbg.enterRule(getGrammarFileName(), "typeParameter"); 1869 if ( getRuleLevel()==0 ) {dbg.commence();} 1870 incRuleLevel(); 1871 dbg.location(397, 1); 1872 1873 try { 1874 if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; } 1875 // src/com/google/doclava/parser/Java.g:398:5: ( IDENTIFIER ( 'extends' typeBound )? ) 1876 dbg.enterAlt(1); 1877 1878 // src/com/google/doclava/parser/Java.g:398:9: IDENTIFIER ( 'extends' typeBound )? 1879 { 1880 dbg.location(398,9); 1881 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeParameter868); if (state.failed) return ; 1882 dbg.location(399,9); 1883 // src/com/google/doclava/parser/Java.g:399:9: ( 'extends' typeBound )? 1884 int alt20=2; 1885 try { dbg.enterSubRule(20); 1886 try { dbg.enterDecision(20, decisionCanBacktrack[20]); 1887 1888 int LA20_0 = input.LA(1); 1889 1890 if ( (LA20_0==EXTENDS) ) { 1891 alt20=1; 1892 } 1893 } finally {dbg.exitDecision(20);} 1894 1895 switch (alt20) { 1896 case 1 : 1897 dbg.enterAlt(1); 1898 1899 // src/com/google/doclava/parser/Java.g:399:10: 'extends' typeBound 1900 { 1901 dbg.location(399,10); 1902 match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameter879); if (state.failed) return ; 1903 dbg.location(399,20); 1904 pushFollow(FOLLOW_typeBound_in_typeParameter881); 1905 typeBound(); 1906 1907 state._fsp--; 1908 if (state.failed) return ; 1909 1910 } 1911 break; 1912 1913 } 1914 } finally {dbg.exitSubRule(20);} 1915 1916 1917 } 1918 1919 } 1920 catch (RecognitionException re) { 1921 reportError(re); 1922 recover(input,re); 1923 } 1924 finally { 1925 if ( state.backtracking>0 ) { memoize(input, 12, typeParameter_StartIndex); } 1926 } 1927 dbg.location(401, 5); 1928 1929 } 1930 finally { 1931 dbg.exitRule(getGrammarFileName(), "typeParameter"); 1932 decRuleLevel(); 1933 if ( getRuleLevel()==0 ) {dbg.terminate();} 1934 } 1935 1936 return ; 1937 } 1938 // $ANTLR end "typeParameter" 1939 1940 1941 // $ANTLR start "typeBound" 1942 // src/com/google/doclava/parser/Java.g:404:1: typeBound : type ( '&' type )* ; typeBound()1943 public final void typeBound() throws RecognitionException { 1944 int typeBound_StartIndex = input.index(); 1945 try { dbg.enterRule(getGrammarFileName(), "typeBound"); 1946 if ( getRuleLevel()==0 ) {dbg.commence();} 1947 incRuleLevel(); 1948 dbg.location(404, 1); 1949 1950 try { 1951 if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; } 1952 // src/com/google/doclava/parser/Java.g:405:5: ( type ( '&' type )* ) 1953 dbg.enterAlt(1); 1954 1955 // src/com/google/doclava/parser/Java.g:405:9: type ( '&' type )* 1956 { 1957 dbg.location(405,9); 1958 pushFollow(FOLLOW_type_in_typeBound912); 1959 type(); 1960 1961 state._fsp--; 1962 if (state.failed) return ; 1963 dbg.location(406,9); 1964 // src/com/google/doclava/parser/Java.g:406:9: ( '&' type )* 1965 try { dbg.enterSubRule(21); 1966 1967 loop21: 1968 do { 1969 int alt21=2; 1970 try { dbg.enterDecision(21, decisionCanBacktrack[21]); 1971 1972 int LA21_0 = input.LA(1); 1973 1974 if ( (LA21_0==AMP) ) { 1975 alt21=1; 1976 } 1977 1978 1979 } finally {dbg.exitDecision(21);} 1980 1981 switch (alt21) { 1982 case 1 : 1983 dbg.enterAlt(1); 1984 1985 // src/com/google/doclava/parser/Java.g:406:10: '&' type 1986 { 1987 dbg.location(406,10); 1988 match(input,AMP,FOLLOW_AMP_in_typeBound923); if (state.failed) return ; 1989 dbg.location(406,14); 1990 pushFollow(FOLLOW_type_in_typeBound925); 1991 type(); 1992 1993 state._fsp--; 1994 if (state.failed) return ; 1995 1996 } 1997 break; 1998 1999 default : 2000 break loop21; 2001 } 2002 } while (true); 2003 } finally {dbg.exitSubRule(21);} 2004 2005 2006 } 2007 2008 } 2009 catch (RecognitionException re) { 2010 reportError(re); 2011 recover(input,re); 2012 } 2013 finally { 2014 if ( state.backtracking>0 ) { memoize(input, 13, typeBound_StartIndex); } 2015 } 2016 dbg.location(408, 5); 2017 2018 } 2019 finally { 2020 dbg.exitRule(getGrammarFileName(), "typeBound"); 2021 decRuleLevel(); 2022 if ( getRuleLevel()==0 ) {dbg.terminate();} 2023 } 2024 2025 return ; 2026 } 2027 // $ANTLR end "typeBound" 2028 2029 2030 // $ANTLR start "enumDeclaration" 2031 // src/com/google/doclava/parser/Java.g:411:1: enumDeclaration : modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody ; enumDeclaration()2032 public final void enumDeclaration() throws RecognitionException { 2033 int enumDeclaration_StartIndex = input.index(); 2034 try { dbg.enterRule(getGrammarFileName(), "enumDeclaration"); 2035 if ( getRuleLevel()==0 ) {dbg.commence();} 2036 incRuleLevel(); 2037 dbg.location(411, 1); 2038 2039 try { 2040 if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; } 2041 // src/com/google/doclava/parser/Java.g:412:5: ( modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody ) 2042 dbg.enterAlt(1); 2043 2044 // src/com/google/doclava/parser/Java.g:412:9: modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody 2045 { 2046 dbg.location(412,9); 2047 pushFollow(FOLLOW_modifiers_in_enumDeclaration956); 2048 modifiers(); 2049 2050 state._fsp--; 2051 if (state.failed) return ; 2052 dbg.location(413,9); 2053 // src/com/google/doclava/parser/Java.g:413:9: ( 'enum' ) 2054 dbg.enterAlt(1); 2055 2056 // src/com/google/doclava/parser/Java.g:413:10: 'enum' 2057 { 2058 dbg.location(413,10); 2059 match(input,ENUM,FOLLOW_ENUM_in_enumDeclaration967); if (state.failed) return ; 2060 2061 } 2062 2063 dbg.location(415,9); 2064 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumDeclaration987); if (state.failed) return ; 2065 dbg.location(416,9); 2066 // src/com/google/doclava/parser/Java.g:416:9: ( 'implements' typeList )? 2067 int alt22=2; 2068 try { dbg.enterSubRule(22); 2069 try { dbg.enterDecision(22, decisionCanBacktrack[22]); 2070 2071 int LA22_0 = input.LA(1); 2072 2073 if ( (LA22_0==IMPLEMENTS) ) { 2074 alt22=1; 2075 } 2076 } finally {dbg.exitDecision(22);} 2077 2078 switch (alt22) { 2079 case 1 : 2080 dbg.enterAlt(1); 2081 2082 // src/com/google/doclava/parser/Java.g:416:10: 'implements' typeList 2083 { 2084 dbg.location(416,10); 2085 match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_enumDeclaration998); if (state.failed) return ; 2086 dbg.location(416,23); 2087 pushFollow(FOLLOW_typeList_in_enumDeclaration1000); 2088 typeList(); 2089 2090 state._fsp--; 2091 if (state.failed) return ; 2092 2093 } 2094 break; 2095 2096 } 2097 } finally {dbg.exitSubRule(22);} 2098 2099 dbg.location(418,9); 2100 pushFollow(FOLLOW_enumBody_in_enumDeclaration1021); 2101 enumBody(); 2102 2103 state._fsp--; 2104 if (state.failed) return ; 2105 2106 } 2107 2108 } 2109 catch (RecognitionException re) { 2110 reportError(re); 2111 recover(input,re); 2112 } 2113 finally { 2114 if ( state.backtracking>0 ) { memoize(input, 14, enumDeclaration_StartIndex); } 2115 } 2116 dbg.location(419, 5); 2117 2118 } 2119 finally { 2120 dbg.exitRule(getGrammarFileName(), "enumDeclaration"); 2121 decRuleLevel(); 2122 if ( getRuleLevel()==0 ) {dbg.terminate();} 2123 } 2124 2125 return ; 2126 } 2127 // $ANTLR end "enumDeclaration" 2128 2129 2130 // $ANTLR start "enumBody" 2131 // src/com/google/doclava/parser/Java.g:422:1: enumBody : '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' ; enumBody()2132 public final void enumBody() throws RecognitionException { 2133 int enumBody_StartIndex = input.index(); 2134 try { dbg.enterRule(getGrammarFileName(), "enumBody"); 2135 if ( getRuleLevel()==0 ) {dbg.commence();} 2136 incRuleLevel(); 2137 dbg.location(422, 1); 2138 2139 try { 2140 if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; } 2141 // src/com/google/doclava/parser/Java.g:423:5: ( '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' ) 2142 dbg.enterAlt(1); 2143 2144 // src/com/google/doclava/parser/Java.g:423:9: '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' 2145 { 2146 dbg.location(423,9); 2147 match(input,LBRACE,FOLLOW_LBRACE_in_enumBody1041); if (state.failed) return ; 2148 dbg.location(424,9); 2149 // src/com/google/doclava/parser/Java.g:424:9: ( enumConstants )? 2150 int alt23=2; 2151 try { dbg.enterSubRule(23); 2152 try { dbg.enterDecision(23, decisionCanBacktrack[23]); 2153 2154 int LA23_0 = input.LA(1); 2155 2156 if ( (LA23_0==IDENTIFIER||LA23_0==MONKEYS_AT) ) { 2157 alt23=1; 2158 } 2159 } finally {dbg.exitDecision(23);} 2160 2161 switch (alt23) { 2162 case 1 : 2163 dbg.enterAlt(1); 2164 2165 // src/com/google/doclava/parser/Java.g:424:10: enumConstants 2166 { 2167 dbg.location(424,10); 2168 pushFollow(FOLLOW_enumConstants_in_enumBody1052); 2169 enumConstants(); 2170 2171 state._fsp--; 2172 if (state.failed) return ; 2173 2174 } 2175 break; 2176 2177 } 2178 } finally {dbg.exitSubRule(23);} 2179 2180 dbg.location(426,9); 2181 // src/com/google/doclava/parser/Java.g:426:9: ( ',' )? 2182 int alt24=2; 2183 try { dbg.enterSubRule(24); 2184 try { dbg.enterDecision(24, decisionCanBacktrack[24]); 2185 2186 int LA24_0 = input.LA(1); 2187 2188 if ( (LA24_0==COMMA) ) { 2189 alt24=1; 2190 } 2191 } finally {dbg.exitDecision(24);} 2192 2193 switch (alt24) { 2194 case 1 : 2195 dbg.enterAlt(1); 2196 2197 // src/com/google/doclava/parser/Java.g:0:0: ',' 2198 { 2199 dbg.location(426,9); 2200 match(input,COMMA,FOLLOW_COMMA_in_enumBody1073); if (state.failed) return ; 2201 2202 } 2203 break; 2204 2205 } 2206 } finally {dbg.exitSubRule(24);} 2207 2208 dbg.location(427,9); 2209 // src/com/google/doclava/parser/Java.g:427:9: ( enumBodyDeclarations )? 2210 int alt25=2; 2211 try { dbg.enterSubRule(25); 2212 try { dbg.enterDecision(25, decisionCanBacktrack[25]); 2213 2214 int LA25_0 = input.LA(1); 2215 2216 if ( (LA25_0==SEMI) ) { 2217 alt25=1; 2218 } 2219 } finally {dbg.exitDecision(25);} 2220 2221 switch (alt25) { 2222 case 1 : 2223 dbg.enterAlt(1); 2224 2225 // src/com/google/doclava/parser/Java.g:427:10: enumBodyDeclarations 2226 { 2227 dbg.location(427,10); 2228 pushFollow(FOLLOW_enumBodyDeclarations_in_enumBody1085); 2229 enumBodyDeclarations(); 2230 2231 state._fsp--; 2232 if (state.failed) return ; 2233 2234 } 2235 break; 2236 2237 } 2238 } finally {dbg.exitSubRule(25);} 2239 2240 dbg.location(429,9); 2241 match(input,RBRACE,FOLLOW_RBRACE_in_enumBody1106); if (state.failed) return ; 2242 2243 } 2244 2245 } 2246 catch (RecognitionException re) { 2247 reportError(re); 2248 recover(input,re); 2249 } 2250 finally { 2251 if ( state.backtracking>0 ) { memoize(input, 15, enumBody_StartIndex); } 2252 } 2253 dbg.location(430, 5); 2254 2255 } 2256 finally { 2257 dbg.exitRule(getGrammarFileName(), "enumBody"); 2258 decRuleLevel(); 2259 if ( getRuleLevel()==0 ) {dbg.terminate();} 2260 } 2261 2262 return ; 2263 } 2264 // $ANTLR end "enumBody" 2265 2266 2267 // $ANTLR start "enumConstants" 2268 // src/com/google/doclava/parser/Java.g:432:1: enumConstants : enumConstant ( ',' enumConstant )* ; enumConstants()2269 public final void enumConstants() throws RecognitionException { 2270 int enumConstants_StartIndex = input.index(); 2271 try { dbg.enterRule(getGrammarFileName(), "enumConstants"); 2272 if ( getRuleLevel()==0 ) {dbg.commence();} 2273 incRuleLevel(); 2274 dbg.location(432, 1); 2275 2276 try { 2277 if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; } 2278 // src/com/google/doclava/parser/Java.g:433:5: ( enumConstant ( ',' enumConstant )* ) 2279 dbg.enterAlt(1); 2280 2281 // src/com/google/doclava/parser/Java.g:433:9: enumConstant ( ',' enumConstant )* 2282 { 2283 dbg.location(433,9); 2284 pushFollow(FOLLOW_enumConstant_in_enumConstants1125); 2285 enumConstant(); 2286 2287 state._fsp--; 2288 if (state.failed) return ; 2289 dbg.location(434,9); 2290 // src/com/google/doclava/parser/Java.g:434:9: ( ',' enumConstant )* 2291 try { dbg.enterSubRule(26); 2292 2293 loop26: 2294 do { 2295 int alt26=2; 2296 try { dbg.enterDecision(26, decisionCanBacktrack[26]); 2297 2298 int LA26_0 = input.LA(1); 2299 2300 if ( (LA26_0==COMMA) ) { 2301 int LA26_1 = input.LA(2); 2302 2303 if ( (LA26_1==IDENTIFIER||LA26_1==MONKEYS_AT) ) { 2304 alt26=1; 2305 } 2306 2307 2308 } 2309 2310 2311 } finally {dbg.exitDecision(26);} 2312 2313 switch (alt26) { 2314 case 1 : 2315 dbg.enterAlt(1); 2316 2317 // src/com/google/doclava/parser/Java.g:434:10: ',' enumConstant 2318 { 2319 dbg.location(434,10); 2320 match(input,COMMA,FOLLOW_COMMA_in_enumConstants1136); if (state.failed) return ; 2321 dbg.location(434,14); 2322 pushFollow(FOLLOW_enumConstant_in_enumConstants1138); 2323 enumConstant(); 2324 2325 state._fsp--; 2326 if (state.failed) return ; 2327 2328 } 2329 break; 2330 2331 default : 2332 break loop26; 2333 } 2334 } while (true); 2335 } finally {dbg.exitSubRule(26);} 2336 2337 2338 } 2339 2340 } 2341 catch (RecognitionException re) { 2342 reportError(re); 2343 recover(input,re); 2344 } 2345 finally { 2346 if ( state.backtracking>0 ) { memoize(input, 16, enumConstants_StartIndex); } 2347 } 2348 dbg.location(436, 5); 2349 2350 } 2351 finally { 2352 dbg.exitRule(getGrammarFileName(), "enumConstants"); 2353 decRuleLevel(); 2354 if ( getRuleLevel()==0 ) {dbg.terminate();} 2355 } 2356 2357 return ; 2358 } 2359 // $ANTLR end "enumConstants" 2360 2361 2362 // $ANTLR start "enumConstant" 2363 // src/com/google/doclava/parser/Java.g:438:1: enumConstant : ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ; enumConstant()2364 public final void enumConstant() throws RecognitionException { 2365 int enumConstant_StartIndex = input.index(); 2366 try { dbg.enterRule(getGrammarFileName(), "enumConstant"); 2367 if ( getRuleLevel()==0 ) {dbg.commence();} 2368 incRuleLevel(); 2369 dbg.location(438, 1); 2370 2371 try { 2372 if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; } 2373 // src/com/google/doclava/parser/Java.g:443:5: ( ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ) 2374 dbg.enterAlt(1); 2375 2376 // src/com/google/doclava/parser/Java.g:443:9: ( annotations )? IDENTIFIER ( arguments )? ( classBody )? 2377 { 2378 dbg.location(443,9); 2379 // src/com/google/doclava/parser/Java.g:443:9: ( annotations )? 2380 int alt27=2; 2381 try { dbg.enterSubRule(27); 2382 try { dbg.enterDecision(27, decisionCanBacktrack[27]); 2383 2384 int LA27_0 = input.LA(1); 2385 2386 if ( (LA27_0==MONKEYS_AT) ) { 2387 alt27=1; 2388 } 2389 } finally {dbg.exitDecision(27);} 2390 2391 switch (alt27) { 2392 case 1 : 2393 dbg.enterAlt(1); 2394 2395 // src/com/google/doclava/parser/Java.g:443:10: annotations 2396 { 2397 dbg.location(443,10); 2398 pushFollow(FOLLOW_annotations_in_enumConstant1171); 2399 annotations(); 2400 2401 state._fsp--; 2402 if (state.failed) return ; 2403 2404 } 2405 break; 2406 2407 } 2408 } finally {dbg.exitSubRule(27);} 2409 2410 dbg.location(445,9); 2411 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant1192); if (state.failed) return ; 2412 dbg.location(446,9); 2413 // src/com/google/doclava/parser/Java.g:446:9: ( arguments )? 2414 int alt28=2; 2415 try { dbg.enterSubRule(28); 2416 try { dbg.enterDecision(28, decisionCanBacktrack[28]); 2417 2418 int LA28_0 = input.LA(1); 2419 2420 if ( (LA28_0==LPAREN) ) { 2421 alt28=1; 2422 } 2423 } finally {dbg.exitDecision(28);} 2424 2425 switch (alt28) { 2426 case 1 : 2427 dbg.enterAlt(1); 2428 2429 // src/com/google/doclava/parser/Java.g:446:10: arguments 2430 { 2431 dbg.location(446,10); 2432 pushFollow(FOLLOW_arguments_in_enumConstant1203); 2433 arguments(); 2434 2435 state._fsp--; 2436 if (state.failed) return ; 2437 2438 } 2439 break; 2440 2441 } 2442 } finally {dbg.exitSubRule(28);} 2443 2444 dbg.location(448,9); 2445 // src/com/google/doclava/parser/Java.g:448:9: ( classBody )? 2446 int alt29=2; 2447 try { dbg.enterSubRule(29); 2448 try { dbg.enterDecision(29, decisionCanBacktrack[29]); 2449 2450 int LA29_0 = input.LA(1); 2451 2452 if ( (LA29_0==LBRACE) ) { 2453 alt29=1; 2454 } 2455 } finally {dbg.exitDecision(29);} 2456 2457 switch (alt29) { 2458 case 1 : 2459 dbg.enterAlt(1); 2460 2461 // src/com/google/doclava/parser/Java.g:448:10: classBody 2462 { 2463 dbg.location(448,10); 2464 pushFollow(FOLLOW_classBody_in_enumConstant1225); 2465 classBody(); 2466 2467 state._fsp--; 2468 if (state.failed) return ; 2469 2470 } 2471 break; 2472 2473 } 2474 } finally {dbg.exitSubRule(29);} 2475 2476 2477 } 2478 2479 } 2480 catch (RecognitionException re) { 2481 reportError(re); 2482 recover(input,re); 2483 } 2484 finally { 2485 if ( state.backtracking>0 ) { memoize(input, 17, enumConstant_StartIndex); } 2486 } 2487 dbg.location(452, 5); 2488 2489 } 2490 finally { 2491 dbg.exitRule(getGrammarFileName(), "enumConstant"); 2492 decRuleLevel(); 2493 if ( getRuleLevel()==0 ) {dbg.terminate();} 2494 } 2495 2496 return ; 2497 } 2498 // $ANTLR end "enumConstant" 2499 2500 2501 // $ANTLR start "enumBodyDeclarations" 2502 // src/com/google/doclava/parser/Java.g:454:1: enumBodyDeclarations : ';' ( classBodyDeclaration )* ; enumBodyDeclarations()2503 public final void enumBodyDeclarations() throws RecognitionException { 2504 int enumBodyDeclarations_StartIndex = input.index(); 2505 try { dbg.enterRule(getGrammarFileName(), "enumBodyDeclarations"); 2506 if ( getRuleLevel()==0 ) {dbg.commence();} 2507 incRuleLevel(); 2508 dbg.location(454, 1); 2509 2510 try { 2511 if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; } 2512 // src/com/google/doclava/parser/Java.g:455:5: ( ';' ( classBodyDeclaration )* ) 2513 dbg.enterAlt(1); 2514 2515 // src/com/google/doclava/parser/Java.g:455:9: ';' ( classBodyDeclaration )* 2516 { 2517 dbg.location(455,9); 2518 match(input,SEMI,FOLLOW_SEMI_in_enumBodyDeclarations1265); if (state.failed) return ; 2519 dbg.location(456,9); 2520 // src/com/google/doclava/parser/Java.g:456:9: ( classBodyDeclaration )* 2521 try { dbg.enterSubRule(30); 2522 2523 loop30: 2524 do { 2525 int alt30=2; 2526 try { dbg.enterDecision(30, decisionCanBacktrack[30]); 2527 2528 int LA30_0 = input.LA(1); 2529 2530 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) ) { 2531 alt30=1; 2532 } 2533 2534 2535 } finally {dbg.exitDecision(30);} 2536 2537 switch (alt30) { 2538 case 1 : 2539 dbg.enterAlt(1); 2540 2541 // src/com/google/doclava/parser/Java.g:456:10: classBodyDeclaration 2542 { 2543 dbg.location(456,10); 2544 pushFollow(FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276); 2545 classBodyDeclaration(); 2546 2547 state._fsp--; 2548 if (state.failed) return ; 2549 2550 } 2551 break; 2552 2553 default : 2554 break loop30; 2555 } 2556 } while (true); 2557 } finally {dbg.exitSubRule(30);} 2558 2559 2560 } 2561 2562 } 2563 catch (RecognitionException re) { 2564 reportError(re); 2565 recover(input,re); 2566 } 2567 finally { 2568 if ( state.backtracking>0 ) { memoize(input, 18, enumBodyDeclarations_StartIndex); } 2569 } 2570 dbg.location(458, 5); 2571 2572 } 2573 finally { 2574 dbg.exitRule(getGrammarFileName(), "enumBodyDeclarations"); 2575 decRuleLevel(); 2576 if ( getRuleLevel()==0 ) {dbg.terminate();} 2577 } 2578 2579 return ; 2580 } 2581 // $ANTLR end "enumBodyDeclarations" 2582 2583 2584 // $ANTLR start "interfaceDeclaration" 2585 // src/com/google/doclava/parser/Java.g:460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration ); interfaceDeclaration()2586 public final void interfaceDeclaration() throws RecognitionException { 2587 int interfaceDeclaration_StartIndex = input.index(); 2588 try { dbg.enterRule(getGrammarFileName(), "interfaceDeclaration"); 2589 if ( getRuleLevel()==0 ) {dbg.commence();} 2590 incRuleLevel(); 2591 dbg.location(460, 1); 2592 2593 try { 2594 if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; } 2595 // src/com/google/doclava/parser/Java.g:461:5: ( normalInterfaceDeclaration | annotationTypeDeclaration ) 2596 int alt31=2; 2597 try { dbg.enterDecision(31, decisionCanBacktrack[31]); 2598 2599 try { 2600 isCyclicDecision = true; 2601 alt31 = dfa31.predict(input); 2602 } 2603 catch (NoViableAltException nvae) { 2604 dbg.recognitionException(nvae); 2605 throw nvae; 2606 } 2607 } finally {dbg.exitDecision(31);} 2608 2609 switch (alt31) { 2610 case 1 : 2611 dbg.enterAlt(1); 2612 2613 // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration 2614 { 2615 dbg.location(461,9); 2616 pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306); 2617 normalInterfaceDeclaration(); 2618 2619 state._fsp--; 2620 if (state.failed) return ; 2621 2622 } 2623 break; 2624 case 2 : 2625 dbg.enterAlt(2); 2626 2627 // src/com/google/doclava/parser/Java.g:462:9: annotationTypeDeclaration 2628 { 2629 dbg.location(462,9); 2630 pushFollow(FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316); 2631 annotationTypeDeclaration(); 2632 2633 state._fsp--; 2634 if (state.failed) return ; 2635 2636 } 2637 break; 2638 2639 } 2640 } 2641 catch (RecognitionException re) { 2642 reportError(re); 2643 recover(input,re); 2644 } 2645 finally { 2646 if ( state.backtracking>0 ) { memoize(input, 19, interfaceDeclaration_StartIndex); } 2647 } 2648 dbg.location(463, 5); 2649 2650 } 2651 finally { 2652 dbg.exitRule(getGrammarFileName(), "interfaceDeclaration"); 2653 decRuleLevel(); 2654 if ( getRuleLevel()==0 ) {dbg.terminate();} 2655 } 2656 2657 return ; 2658 } 2659 // $ANTLR end "interfaceDeclaration" 2660 2661 2662 // $ANTLR start "normalInterfaceDeclaration" 2663 // src/com/google/doclava/parser/Java.g:465:1: normalInterfaceDeclaration : modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody ; normalInterfaceDeclaration()2664 public final void normalInterfaceDeclaration() throws RecognitionException { 2665 int normalInterfaceDeclaration_StartIndex = input.index(); 2666 try { dbg.enterRule(getGrammarFileName(), "normalInterfaceDeclaration"); 2667 if ( getRuleLevel()==0 ) {dbg.commence();} 2668 incRuleLevel(); 2669 dbg.location(465, 1); 2670 2671 try { 2672 if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return ; } 2673 // src/com/google/doclava/parser/Java.g:466:5: ( modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody ) 2674 dbg.enterAlt(1); 2675 2676 // src/com/google/doclava/parser/Java.g:466:9: modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody 2677 { 2678 dbg.location(466,9); 2679 pushFollow(FOLLOW_modifiers_in_normalInterfaceDeclaration1335); 2680 modifiers(); 2681 2682 state._fsp--; 2683 if (state.failed) return ; 2684 dbg.location(466,19); 2685 match(input,INTERFACE,FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337); if (state.failed) return ; 2686 dbg.location(466,31); 2687 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339); if (state.failed) return ; 2688 dbg.location(467,9); 2689 // src/com/google/doclava/parser/Java.g:467:9: ( typeParameters )? 2690 int alt32=2; 2691 try { dbg.enterSubRule(32); 2692 try { dbg.enterDecision(32, decisionCanBacktrack[32]); 2693 2694 int LA32_0 = input.LA(1); 2695 2696 if ( (LA32_0==LT) ) { 2697 alt32=1; 2698 } 2699 } finally {dbg.exitDecision(32);} 2700 2701 switch (alt32) { 2702 case 1 : 2703 dbg.enterAlt(1); 2704 2705 // src/com/google/doclava/parser/Java.g:467:10: typeParameters 2706 { 2707 dbg.location(467,10); 2708 pushFollow(FOLLOW_typeParameters_in_normalInterfaceDeclaration1350); 2709 typeParameters(); 2710 2711 state._fsp--; 2712 if (state.failed) return ; 2713 2714 } 2715 break; 2716 2717 } 2718 } finally {dbg.exitSubRule(32);} 2719 2720 dbg.location(469,9); 2721 // src/com/google/doclava/parser/Java.g:469:9: ( 'extends' typeList )? 2722 int alt33=2; 2723 try { dbg.enterSubRule(33); 2724 try { dbg.enterDecision(33, decisionCanBacktrack[33]); 2725 2726 int LA33_0 = input.LA(1); 2727 2728 if ( (LA33_0==EXTENDS) ) { 2729 alt33=1; 2730 } 2731 } finally {dbg.exitDecision(33);} 2732 2733 switch (alt33) { 2734 case 1 : 2735 dbg.enterAlt(1); 2736 2737 // src/com/google/doclava/parser/Java.g:469:10: 'extends' typeList 2738 { 2739 dbg.location(469,10); 2740 match(input,EXTENDS,FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372); if (state.failed) return ; 2741 dbg.location(469,20); 2742 pushFollow(FOLLOW_typeList_in_normalInterfaceDeclaration1374); 2743 typeList(); 2744 2745 state._fsp--; 2746 if (state.failed) return ; 2747 2748 } 2749 break; 2750 2751 } 2752 } finally {dbg.exitSubRule(33);} 2753 2754 dbg.location(471,9); 2755 pushFollow(FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395); 2756 interfaceBody(); 2757 2758 state._fsp--; 2759 if (state.failed) return ; 2760 2761 } 2762 2763 } 2764 catch (RecognitionException re) { 2765 reportError(re); 2766 recover(input,re); 2767 } 2768 finally { 2769 if ( state.backtracking>0 ) { memoize(input, 20, normalInterfaceDeclaration_StartIndex); } 2770 } 2771 dbg.location(472, 5); 2772 2773 } 2774 finally { 2775 dbg.exitRule(getGrammarFileName(), "normalInterfaceDeclaration"); 2776 decRuleLevel(); 2777 if ( getRuleLevel()==0 ) {dbg.terminate();} 2778 } 2779 2780 return ; 2781 } 2782 // $ANTLR end "normalInterfaceDeclaration" 2783 2784 2785 // $ANTLR start "typeList" 2786 // src/com/google/doclava/parser/Java.g:474:1: typeList : type ( ',' type )* ; typeList()2787 public final void typeList() throws RecognitionException { 2788 int typeList_StartIndex = input.index(); 2789 try { dbg.enterRule(getGrammarFileName(), "typeList"); 2790 if ( getRuleLevel()==0 ) {dbg.commence();} 2791 incRuleLevel(); 2792 dbg.location(474, 1); 2793 2794 try { 2795 if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; } 2796 // src/com/google/doclava/parser/Java.g:475:5: ( type ( ',' type )* ) 2797 dbg.enterAlt(1); 2798 2799 // src/com/google/doclava/parser/Java.g:475:9: type ( ',' type )* 2800 { 2801 dbg.location(475,9); 2802 pushFollow(FOLLOW_type_in_typeList1414); 2803 type(); 2804 2805 state._fsp--; 2806 if (state.failed) return ; 2807 dbg.location(476,9); 2808 // src/com/google/doclava/parser/Java.g:476:9: ( ',' type )* 2809 try { dbg.enterSubRule(34); 2810 2811 loop34: 2812 do { 2813 int alt34=2; 2814 try { dbg.enterDecision(34, decisionCanBacktrack[34]); 2815 2816 int LA34_0 = input.LA(1); 2817 2818 if ( (LA34_0==COMMA) ) { 2819 alt34=1; 2820 } 2821 2822 2823 } finally {dbg.exitDecision(34);} 2824 2825 switch (alt34) { 2826 case 1 : 2827 dbg.enterAlt(1); 2828 2829 // src/com/google/doclava/parser/Java.g:476:10: ',' type 2830 { 2831 dbg.location(476,10); 2832 match(input,COMMA,FOLLOW_COMMA_in_typeList1425); if (state.failed) return ; 2833 dbg.location(476,14); 2834 pushFollow(FOLLOW_type_in_typeList1427); 2835 type(); 2836 2837 state._fsp--; 2838 if (state.failed) return ; 2839 2840 } 2841 break; 2842 2843 default : 2844 break loop34; 2845 } 2846 } while (true); 2847 } finally {dbg.exitSubRule(34);} 2848 2849 2850 } 2851 2852 } 2853 catch (RecognitionException re) { 2854 reportError(re); 2855 recover(input,re); 2856 } 2857 finally { 2858 if ( state.backtracking>0 ) { memoize(input, 21, typeList_StartIndex); } 2859 } 2860 dbg.location(478, 5); 2861 2862 } 2863 finally { 2864 dbg.exitRule(getGrammarFileName(), "typeList"); 2865 decRuleLevel(); 2866 if ( getRuleLevel()==0 ) {dbg.terminate();} 2867 } 2868 2869 return ; 2870 } 2871 // $ANTLR end "typeList" 2872 2873 2874 // $ANTLR start "classBody" 2875 // src/com/google/doclava/parser/Java.g:480:1: classBody : '{' ( classBodyDeclaration )* '}' ; classBody()2876 public final void classBody() throws RecognitionException { 2877 int classBody_StartIndex = input.index(); 2878 try { dbg.enterRule(getGrammarFileName(), "classBody"); 2879 if ( getRuleLevel()==0 ) {dbg.commence();} 2880 incRuleLevel(); 2881 dbg.location(480, 1); 2882 2883 try { 2884 if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; } 2885 // src/com/google/doclava/parser/Java.g:481:5: ( '{' ( classBodyDeclaration )* '}' ) 2886 dbg.enterAlt(1); 2887 2888 // src/com/google/doclava/parser/Java.g:481:9: '{' ( classBodyDeclaration )* '}' 2889 { 2890 dbg.location(481,9); 2891 match(input,LBRACE,FOLLOW_LBRACE_in_classBody1457); if (state.failed) return ; 2892 dbg.location(482,9); 2893 // src/com/google/doclava/parser/Java.g:482:9: ( classBodyDeclaration )* 2894 try { dbg.enterSubRule(35); 2895 2896 loop35: 2897 do { 2898 int alt35=2; 2899 try { dbg.enterDecision(35, decisionCanBacktrack[35]); 2900 2901 int LA35_0 = input.LA(1); 2902 2903 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) ) { 2904 alt35=1; 2905 } 2906 2907 2908 } finally {dbg.exitDecision(35);} 2909 2910 switch (alt35) { 2911 case 1 : 2912 dbg.enterAlt(1); 2913 2914 // src/com/google/doclava/parser/Java.g:482:10: classBodyDeclaration 2915 { 2916 dbg.location(482,10); 2917 pushFollow(FOLLOW_classBodyDeclaration_in_classBody1468); 2918 classBodyDeclaration(); 2919 2920 state._fsp--; 2921 if (state.failed) return ; 2922 2923 } 2924 break; 2925 2926 default : 2927 break loop35; 2928 } 2929 } while (true); 2930 } finally {dbg.exitSubRule(35);} 2931 2932 dbg.location(484,9); 2933 match(input,RBRACE,FOLLOW_RBRACE_in_classBody1489); if (state.failed) return ; 2934 2935 } 2936 2937 } 2938 catch (RecognitionException re) { 2939 reportError(re); 2940 recover(input,re); 2941 } 2942 finally { 2943 if ( state.backtracking>0 ) { memoize(input, 22, classBody_StartIndex); } 2944 } 2945 dbg.location(485, 5); 2946 2947 } 2948 finally { 2949 dbg.exitRule(getGrammarFileName(), "classBody"); 2950 decRuleLevel(); 2951 if ( getRuleLevel()==0 ) {dbg.terminate();} 2952 } 2953 2954 return ; 2955 } 2956 // $ANTLR end "classBody" 2957 2958 2959 // $ANTLR start "interfaceBody" 2960 // src/com/google/doclava/parser/Java.g:487:1: interfaceBody : '{' ( interfaceBodyDeclaration )* '}' ; interfaceBody()2961 public final void interfaceBody() throws RecognitionException { 2962 int interfaceBody_StartIndex = input.index(); 2963 try { dbg.enterRule(getGrammarFileName(), "interfaceBody"); 2964 if ( getRuleLevel()==0 ) {dbg.commence();} 2965 incRuleLevel(); 2966 dbg.location(487, 1); 2967 2968 try { 2969 if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return ; } 2970 // src/com/google/doclava/parser/Java.g:488:5: ( '{' ( interfaceBodyDeclaration )* '}' ) 2971 dbg.enterAlt(1); 2972 2973 // src/com/google/doclava/parser/Java.g:488:9: '{' ( interfaceBodyDeclaration )* '}' 2974 { 2975 dbg.location(488,9); 2976 match(input,LBRACE,FOLLOW_LBRACE_in_interfaceBody1508); if (state.failed) return ; 2977 dbg.location(489,9); 2978 // src/com/google/doclava/parser/Java.g:489:9: ( interfaceBodyDeclaration )* 2979 try { dbg.enterSubRule(36); 2980 2981 loop36: 2982 do { 2983 int alt36=2; 2984 try { dbg.enterDecision(36, decisionCanBacktrack[36]); 2985 2986 int LA36_0 = input.LA(1); 2987 2988 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) ) { 2989 alt36=1; 2990 } 2991 2992 2993 } finally {dbg.exitDecision(36);} 2994 2995 switch (alt36) { 2996 case 1 : 2997 dbg.enterAlt(1); 2998 2999 // src/com/google/doclava/parser/Java.g:489:10: interfaceBodyDeclaration 3000 { 3001 dbg.location(489,10); 3002 pushFollow(FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519); 3003 interfaceBodyDeclaration(); 3004 3005 state._fsp--; 3006 if (state.failed) return ; 3007 3008 } 3009 break; 3010 3011 default : 3012 break loop36; 3013 } 3014 } while (true); 3015 } finally {dbg.exitSubRule(36);} 3016 3017 dbg.location(491,9); 3018 match(input,RBRACE,FOLLOW_RBRACE_in_interfaceBody1540); if (state.failed) return ; 3019 3020 } 3021 3022 } 3023 catch (RecognitionException re) { 3024 reportError(re); 3025 recover(input,re); 3026 } 3027 finally { 3028 if ( state.backtracking>0 ) { memoize(input, 23, interfaceBody_StartIndex); } 3029 } 3030 dbg.location(492, 5); 3031 3032 } 3033 finally { 3034 dbg.exitRule(getGrammarFileName(), "interfaceBody"); 3035 decRuleLevel(); 3036 if ( getRuleLevel()==0 ) {dbg.terminate();} 3037 } 3038 3039 return ; 3040 } 3041 // $ANTLR end "interfaceBody" 3042 3043 3044 // $ANTLR start "classBodyDeclaration" 3045 // src/com/google/doclava/parser/Java.g:494:1: classBodyDeclaration : ( ';' | ( 'static' )? block | memberDecl ); classBodyDeclaration()3046 public final void classBodyDeclaration() throws RecognitionException { 3047 int classBodyDeclaration_StartIndex = input.index(); 3048 try { dbg.enterRule(getGrammarFileName(), "classBodyDeclaration"); 3049 if ( getRuleLevel()==0 ) {dbg.commence();} 3050 incRuleLevel(); 3051 dbg.location(494, 1); 3052 3053 try { 3054 if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; } 3055 // src/com/google/doclava/parser/Java.g:495:5: ( ';' | ( 'static' )? block | memberDecl ) 3056 int alt38=3; 3057 try { dbg.enterDecision(38, decisionCanBacktrack[38]); 3058 3059 switch ( input.LA(1) ) { 3060 case SEMI: 3061 { 3062 alt38=1; 3063 } 3064 break; 3065 case STATIC: 3066 { 3067 int LA38_2 = input.LA(2); 3068 3069 if ( (LA38_2==LBRACE) ) { 3070 alt38=2; 3071 } 3072 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) ) { 3073 alt38=3; 3074 } 3075 else { 3076 if (state.backtracking>0) {state.failed=true; return ;} 3077 NoViableAltException nvae = 3078 new NoViableAltException("", 38, 2, input); 3079 3080 dbg.recognitionException(nvae); 3081 throw nvae; 3082 } 3083 } 3084 break; 3085 case LBRACE: 3086 { 3087 alt38=2; 3088 } 3089 break; 3090 case IDENTIFIER: 3091 case ABSTRACT: 3092 case BOOLEAN: 3093 case BYTE: 3094 case CHAR: 3095 case CLASS: 3096 case DOUBLE: 3097 case ENUM: 3098 case FINAL: 3099 case FLOAT: 3100 case INT: 3101 case INTERFACE: 3102 case LONG: 3103 case NATIVE: 3104 case PRIVATE: 3105 case PROTECTED: 3106 case PUBLIC: 3107 case SHORT: 3108 case STRICTFP: 3109 case SYNCHRONIZED: 3110 case TRANSIENT: 3111 case VOID: 3112 case VOLATILE: 3113 case MONKEYS_AT: 3114 case LT: 3115 { 3116 alt38=3; 3117 } 3118 break; 3119 default: 3120 if (state.backtracking>0) {state.failed=true; return ;} 3121 NoViableAltException nvae = 3122 new NoViableAltException("", 38, 0, input); 3123 3124 dbg.recognitionException(nvae); 3125 throw nvae; 3126 } 3127 3128 } finally {dbg.exitDecision(38);} 3129 3130 switch (alt38) { 3131 case 1 : 3132 dbg.enterAlt(1); 3133 3134 // src/com/google/doclava/parser/Java.g:495:9: ';' 3135 { 3136 dbg.location(495,9); 3137 match(input,SEMI,FOLLOW_SEMI_in_classBodyDeclaration1559); if (state.failed) return ; 3138 3139 } 3140 break; 3141 case 2 : 3142 dbg.enterAlt(2); 3143 3144 // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )? block 3145 { 3146 dbg.location(496,9); 3147 // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )? 3148 int alt37=2; 3149 try { dbg.enterSubRule(37); 3150 try { dbg.enterDecision(37, decisionCanBacktrack[37]); 3151 3152 int LA37_0 = input.LA(1); 3153 3154 if ( (LA37_0==STATIC) ) { 3155 alt37=1; 3156 } 3157 } finally {dbg.exitDecision(37);} 3158 3159 switch (alt37) { 3160 case 1 : 3161 dbg.enterAlt(1); 3162 3163 // src/com/google/doclava/parser/Java.g:496:10: 'static' 3164 { 3165 dbg.location(496,10); 3166 match(input,STATIC,FOLLOW_STATIC_in_classBodyDeclaration1570); if (state.failed) return ; 3167 3168 } 3169 break; 3170 3171 } 3172 } finally {dbg.exitSubRule(37);} 3173 3174 dbg.location(498,9); 3175 pushFollow(FOLLOW_block_in_classBodyDeclaration1591); 3176 block(); 3177 3178 state._fsp--; 3179 if (state.failed) return ; 3180 3181 } 3182 break; 3183 case 3 : 3184 dbg.enterAlt(3); 3185 3186 // src/com/google/doclava/parser/Java.g:499:9: memberDecl 3187 { 3188 dbg.location(499,9); 3189 pushFollow(FOLLOW_memberDecl_in_classBodyDeclaration1601); 3190 memberDecl(); 3191 3192 state._fsp--; 3193 if (state.failed) return ; 3194 3195 } 3196 break; 3197 3198 } 3199 } 3200 catch (RecognitionException re) { 3201 reportError(re); 3202 recover(input,re); 3203 } 3204 finally { 3205 if ( state.backtracking>0 ) { memoize(input, 24, classBodyDeclaration_StartIndex); } 3206 } 3207 dbg.location(500, 5); 3208 3209 } 3210 finally { 3211 dbg.exitRule(getGrammarFileName(), "classBodyDeclaration"); 3212 decRuleLevel(); 3213 if ( getRuleLevel()==0 ) {dbg.terminate();} 3214 } 3215 3216 return ; 3217 } 3218 // $ANTLR end "classBodyDeclaration" 3219 3220 3221 // $ANTLR start "memberDecl" 3222 // src/com/google/doclava/parser/Java.g:502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration ); memberDecl()3223 public final void memberDecl() throws RecognitionException { 3224 int memberDecl_StartIndex = input.index(); 3225 try { dbg.enterRule(getGrammarFileName(), "memberDecl"); 3226 if ( getRuleLevel()==0 ) {dbg.commence();} 3227 incRuleLevel(); 3228 dbg.location(502, 1); 3229 3230 try { 3231 if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; } 3232 // src/com/google/doclava/parser/Java.g:503:5: ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration ) 3233 int alt39=4; 3234 try { dbg.enterDecision(39, decisionCanBacktrack[39]); 3235 3236 try { 3237 isCyclicDecision = true; 3238 alt39 = dfa39.predict(input); 3239 } 3240 catch (NoViableAltException nvae) { 3241 dbg.recognitionException(nvae); 3242 throw nvae; 3243 } 3244 } finally {dbg.exitDecision(39);} 3245 3246 switch (alt39) { 3247 case 1 : 3248 dbg.enterAlt(1); 3249 3250 // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration 3251 { 3252 dbg.location(503,10); 3253 pushFollow(FOLLOW_fieldDeclaration_in_memberDecl1621); 3254 fieldDeclaration(); 3255 3256 state._fsp--; 3257 if (state.failed) return ; 3258 3259 } 3260 break; 3261 case 2 : 3262 dbg.enterAlt(2); 3263 3264 // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration 3265 { 3266 dbg.location(504,10); 3267 pushFollow(FOLLOW_methodDeclaration_in_memberDecl1632); 3268 methodDeclaration(); 3269 3270 state._fsp--; 3271 if (state.failed) return ; 3272 3273 } 3274 break; 3275 case 3 : 3276 dbg.enterAlt(3); 3277 3278 // src/com/google/doclava/parser/Java.g:505:10: classDeclaration 3279 { 3280 dbg.location(505,10); 3281 pushFollow(FOLLOW_classDeclaration_in_memberDecl1643); 3282 classDeclaration(); 3283 3284 state._fsp--; 3285 if (state.failed) return ; 3286 3287 } 3288 break; 3289 case 4 : 3290 dbg.enterAlt(4); 3291 3292 // src/com/google/doclava/parser/Java.g:506:10: interfaceDeclaration 3293 { 3294 dbg.location(506,10); 3295 pushFollow(FOLLOW_interfaceDeclaration_in_memberDecl1654); 3296 interfaceDeclaration(); 3297 3298 state._fsp--; 3299 if (state.failed) return ; 3300 3301 } 3302 break; 3303 3304 } 3305 } 3306 catch (RecognitionException re) { 3307 reportError(re); 3308 recover(input,re); 3309 } 3310 finally { 3311 if ( state.backtracking>0 ) { memoize(input, 25, memberDecl_StartIndex); } 3312 } 3313 dbg.location(507, 5); 3314 3315 } 3316 finally { 3317 dbg.exitRule(getGrammarFileName(), "memberDecl"); 3318 decRuleLevel(); 3319 if ( getRuleLevel()==0 ) {dbg.terminate();} 3320 } 3321 3322 return ; 3323 } 3324 // $ANTLR end "memberDecl" 3325 3326 3327 // $ANTLR start "methodDeclaration" 3328 // 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 | ';' ) ); methodDeclaration()3329 public final void methodDeclaration() throws RecognitionException { 3330 int methodDeclaration_StartIndex = input.index(); 3331 try { dbg.enterRule(getGrammarFileName(), "methodDeclaration"); 3332 if ( getRuleLevel()==0 ) {dbg.commence();} 3333 incRuleLevel(); 3334 dbg.location(510, 1); 3335 3336 try { 3337 if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; } 3338 // 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 | ';' ) ) 3339 int alt49=2; 3340 try { dbg.enterDecision(49, decisionCanBacktrack[49]); 3341 3342 try { 3343 isCyclicDecision = true; 3344 alt49 = dfa49.predict(input); 3345 } 3346 catch (NoViableAltException nvae) { 3347 dbg.recognitionException(nvae); 3348 throw nvae; 3349 } 3350 } finally {dbg.exitDecision(49);} 3351 3352 switch (alt49) { 3353 case 1 : 3354 dbg.enterAlt(1); 3355 3356 // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' 3357 { 3358 dbg.location(513,10); 3359 pushFollow(FOLLOW_modifiers_in_methodDeclaration1691); 3360 modifiers(); 3361 3362 state._fsp--; 3363 if (state.failed) return ; 3364 dbg.location(514,9); 3365 // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )? 3366 int alt40=2; 3367 try { dbg.enterSubRule(40); 3368 try { dbg.enterDecision(40, decisionCanBacktrack[40]); 3369 3370 int LA40_0 = input.LA(1); 3371 3372 if ( (LA40_0==LT) ) { 3373 alt40=1; 3374 } 3375 } finally {dbg.exitDecision(40);} 3376 3377 switch (alt40) { 3378 case 1 : 3379 dbg.enterAlt(1); 3380 3381 // src/com/google/doclava/parser/Java.g:514:10: typeParameters 3382 { 3383 dbg.location(514,10); 3384 pushFollow(FOLLOW_typeParameters_in_methodDeclaration1702); 3385 typeParameters(); 3386 3387 state._fsp--; 3388 if (state.failed) return ; 3389 3390 } 3391 break; 3392 3393 } 3394 } finally {dbg.exitSubRule(40);} 3395 3396 dbg.location(516,9); 3397 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1723); if (state.failed) return ; 3398 dbg.location(517,9); 3399 pushFollow(FOLLOW_formalParameters_in_methodDeclaration1733); 3400 formalParameters(); 3401 3402 state._fsp--; 3403 if (state.failed) return ; 3404 dbg.location(518,9); 3405 // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )? 3406 int alt41=2; 3407 try { dbg.enterSubRule(41); 3408 try { dbg.enterDecision(41, decisionCanBacktrack[41]); 3409 3410 int LA41_0 = input.LA(1); 3411 3412 if ( (LA41_0==THROWS) ) { 3413 alt41=1; 3414 } 3415 } finally {dbg.exitDecision(41);} 3416 3417 switch (alt41) { 3418 case 1 : 3419 dbg.enterAlt(1); 3420 3421 // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList 3422 { 3423 dbg.location(518,10); 3424 match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1744); if (state.failed) return ; 3425 dbg.location(518,19); 3426 pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1746); 3427 qualifiedNameList(); 3428 3429 state._fsp--; 3430 if (state.failed) return ; 3431 3432 } 3433 break; 3434 3435 } 3436 } finally {dbg.exitSubRule(41);} 3437 3438 dbg.location(520,9); 3439 match(input,LBRACE,FOLLOW_LBRACE_in_methodDeclaration1767); if (state.failed) return ; 3440 dbg.location(521,9); 3441 // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )? 3442 int alt42=2; 3443 try { dbg.enterSubRule(42); 3444 try { dbg.enterDecision(42, decisionCanBacktrack[42]); 3445 3446 try { 3447 isCyclicDecision = true; 3448 alt42 = dfa42.predict(input); 3449 } 3450 catch (NoViableAltException nvae) { 3451 dbg.recognitionException(nvae); 3452 throw nvae; 3453 } 3454 } finally {dbg.exitDecision(42);} 3455 3456 switch (alt42) { 3457 case 1 : 3458 dbg.enterAlt(1); 3459 3460 // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation 3461 { 3462 dbg.location(521,10); 3463 pushFollow(FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778); 3464 explicitConstructorInvocation(); 3465 3466 state._fsp--; 3467 if (state.failed) return ; 3468 3469 } 3470 break; 3471 3472 } 3473 } finally {dbg.exitSubRule(42);} 3474 3475 dbg.location(523,9); 3476 // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )* 3477 try { dbg.enterSubRule(43); 3478 3479 loop43: 3480 do { 3481 int alt43=2; 3482 try { dbg.enterDecision(43, decisionCanBacktrack[43]); 3483 3484 int LA43_0 = input.LA(1); 3485 3486 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) ) { 3487 alt43=1; 3488 } 3489 3490 3491 } finally {dbg.exitDecision(43);} 3492 3493 switch (alt43) { 3494 case 1 : 3495 dbg.enterAlt(1); 3496 3497 // src/com/google/doclava/parser/Java.g:523:10: blockStatement 3498 { 3499 dbg.location(523,10); 3500 pushFollow(FOLLOW_blockStatement_in_methodDeclaration1800); 3501 blockStatement(); 3502 3503 state._fsp--; 3504 if (state.failed) return ; 3505 3506 } 3507 break; 3508 3509 default : 3510 break loop43; 3511 } 3512 } while (true); 3513 } finally {dbg.exitSubRule(43);} 3514 3515 dbg.location(525,9); 3516 match(input,RBRACE,FOLLOW_RBRACE_in_methodDeclaration1821); if (state.failed) return ; 3517 3518 } 3519 break; 3520 case 2 : 3521 dbg.enterAlt(2); 3522 3523 // src/com/google/doclava/parser/Java.g:526:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) 3524 { 3525 dbg.location(526,9); 3526 pushFollow(FOLLOW_modifiers_in_methodDeclaration1831); 3527 modifiers(); 3528 3529 state._fsp--; 3530 if (state.failed) return ; 3531 dbg.location(527,9); 3532 // src/com/google/doclava/parser/Java.g:527:9: ( typeParameters )? 3533 int alt44=2; 3534 try { dbg.enterSubRule(44); 3535 try { dbg.enterDecision(44, decisionCanBacktrack[44]); 3536 3537 int LA44_0 = input.LA(1); 3538 3539 if ( (LA44_0==LT) ) { 3540 alt44=1; 3541 } 3542 } finally {dbg.exitDecision(44);} 3543 3544 switch (alt44) { 3545 case 1 : 3546 dbg.enterAlt(1); 3547 3548 // src/com/google/doclava/parser/Java.g:527:10: typeParameters 3549 { 3550 dbg.location(527,10); 3551 pushFollow(FOLLOW_typeParameters_in_methodDeclaration1842); 3552 typeParameters(); 3553 3554 state._fsp--; 3555 if (state.failed) return ; 3556 3557 } 3558 break; 3559 3560 } 3561 } finally {dbg.exitSubRule(44);} 3562 3563 dbg.location(529,9); 3564 // src/com/google/doclava/parser/Java.g:529:9: ( type | 'void' ) 3565 int alt45=2; 3566 try { dbg.enterSubRule(45); 3567 try { dbg.enterDecision(45, decisionCanBacktrack[45]); 3568 3569 int LA45_0 = input.LA(1); 3570 3571 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) ) { 3572 alt45=1; 3573 } 3574 else if ( (LA45_0==VOID) ) { 3575 alt45=2; 3576 } 3577 else { 3578 if (state.backtracking>0) {state.failed=true; return ;} 3579 NoViableAltException nvae = 3580 new NoViableAltException("", 45, 0, input); 3581 3582 dbg.recognitionException(nvae); 3583 throw nvae; 3584 } 3585 } finally {dbg.exitDecision(45);} 3586 3587 switch (alt45) { 3588 case 1 : 3589 dbg.enterAlt(1); 3590 3591 // src/com/google/doclava/parser/Java.g:529:10: type 3592 { 3593 dbg.location(529,10); 3594 pushFollow(FOLLOW_type_in_methodDeclaration1864); 3595 type(); 3596 3597 state._fsp--; 3598 if (state.failed) return ; 3599 3600 } 3601 break; 3602 case 2 : 3603 dbg.enterAlt(2); 3604 3605 // src/com/google/doclava/parser/Java.g:530:13: 'void' 3606 { 3607 dbg.location(530,13); 3608 match(input,VOID,FOLLOW_VOID_in_methodDeclaration1878); if (state.failed) return ; 3609 3610 } 3611 break; 3612 3613 } 3614 } finally {dbg.exitSubRule(45);} 3615 3616 dbg.location(532,9); 3617 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1898); if (state.failed) return ; 3618 dbg.location(533,9); 3619 pushFollow(FOLLOW_formalParameters_in_methodDeclaration1908); 3620 formalParameters(); 3621 3622 state._fsp--; 3623 if (state.failed) return ; 3624 dbg.location(534,9); 3625 // src/com/google/doclava/parser/Java.g:534:9: ( '[' ']' )* 3626 try { dbg.enterSubRule(46); 3627 3628 loop46: 3629 do { 3630 int alt46=2; 3631 try { dbg.enterDecision(46, decisionCanBacktrack[46]); 3632 3633 int LA46_0 = input.LA(1); 3634 3635 if ( (LA46_0==LBRACKET) ) { 3636 alt46=1; 3637 } 3638 3639 3640 } finally {dbg.exitDecision(46);} 3641 3642 switch (alt46) { 3643 case 1 : 3644 dbg.enterAlt(1); 3645 3646 // src/com/google/doclava/parser/Java.g:534:10: '[' ']' 3647 { 3648 dbg.location(534,10); 3649 match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration1919); if (state.failed) return ; 3650 dbg.location(534,14); 3651 match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration1921); if (state.failed) return ; 3652 3653 } 3654 break; 3655 3656 default : 3657 break loop46; 3658 } 3659 } while (true); 3660 } finally {dbg.exitSubRule(46);} 3661 3662 dbg.location(536,9); 3663 // src/com/google/doclava/parser/Java.g:536:9: ( 'throws' qualifiedNameList )? 3664 int alt47=2; 3665 try { dbg.enterSubRule(47); 3666 try { dbg.enterDecision(47, decisionCanBacktrack[47]); 3667 3668 int LA47_0 = input.LA(1); 3669 3670 if ( (LA47_0==THROWS) ) { 3671 alt47=1; 3672 } 3673 } finally {dbg.exitDecision(47);} 3674 3675 switch (alt47) { 3676 case 1 : 3677 dbg.enterAlt(1); 3678 3679 // src/com/google/doclava/parser/Java.g:536:10: 'throws' qualifiedNameList 3680 { 3681 dbg.location(536,10); 3682 match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1943); if (state.failed) return ; 3683 dbg.location(536,19); 3684 pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1945); 3685 qualifiedNameList(); 3686 3687 state._fsp--; 3688 if (state.failed) return ; 3689 3690 } 3691 break; 3692 3693 } 3694 } finally {dbg.exitSubRule(47);} 3695 3696 dbg.location(538,9); 3697 // src/com/google/doclava/parser/Java.g:538:9: ( block | ';' ) 3698 int alt48=2; 3699 try { dbg.enterSubRule(48); 3700 try { dbg.enterDecision(48, decisionCanBacktrack[48]); 3701 3702 int LA48_0 = input.LA(1); 3703 3704 if ( (LA48_0==LBRACE) ) { 3705 alt48=1; 3706 } 3707 else if ( (LA48_0==SEMI) ) { 3708 alt48=2; 3709 } 3710 else { 3711 if (state.backtracking>0) {state.failed=true; return ;} 3712 NoViableAltException nvae = 3713 new NoViableAltException("", 48, 0, input); 3714 3715 dbg.recognitionException(nvae); 3716 throw nvae; 3717 } 3718 } finally {dbg.exitDecision(48);} 3719 3720 switch (alt48) { 3721 case 1 : 3722 dbg.enterAlt(1); 3723 3724 // src/com/google/doclava/parser/Java.g:539:13: block 3725 { 3726 dbg.location(539,13); 3727 pushFollow(FOLLOW_block_in_methodDeclaration1980); 3728 block(); 3729 3730 state._fsp--; 3731 if (state.failed) return ; 3732 3733 } 3734 break; 3735 case 2 : 3736 dbg.enterAlt(2); 3737 3738 // src/com/google/doclava/parser/Java.g:540:13: ';' 3739 { 3740 dbg.location(540,13); 3741 match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration1994); if (state.failed) return ; 3742 3743 } 3744 break; 3745 3746 } 3747 } finally {dbg.exitSubRule(48);} 3748 3749 3750 } 3751 break; 3752 3753 } 3754 } 3755 catch (RecognitionException re) { 3756 reportError(re); 3757 recover(input,re); 3758 } 3759 finally { 3760 if ( state.backtracking>0 ) { memoize(input, 26, methodDeclaration_StartIndex); } 3761 } 3762 dbg.location(542, 5); 3763 3764 } 3765 finally { 3766 dbg.exitRule(getGrammarFileName(), "methodDeclaration"); 3767 decRuleLevel(); 3768 if ( getRuleLevel()==0 ) {dbg.terminate();} 3769 } 3770 3771 return ; 3772 } 3773 // $ANTLR end "methodDeclaration" 3774 3775 3776 // $ANTLR start "fieldDeclaration" 3777 // src/com/google/doclava/parser/Java.g:545:1: fieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ; fieldDeclaration()3778 public final void fieldDeclaration() throws RecognitionException { 3779 int fieldDeclaration_StartIndex = input.index(); 3780 try { dbg.enterRule(getGrammarFileName(), "fieldDeclaration"); 3781 if ( getRuleLevel()==0 ) {dbg.commence();} 3782 incRuleLevel(); 3783 dbg.location(545, 1); 3784 3785 try { 3786 if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return ; } 3787 // src/com/google/doclava/parser/Java.g:546:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ) 3788 dbg.enterAlt(1); 3789 3790 // src/com/google/doclava/parser/Java.g:546:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';' 3791 { 3792 dbg.location(546,9); 3793 pushFollow(FOLLOW_modifiers_in_fieldDeclaration2024); 3794 modifiers(); 3795 3796 state._fsp--; 3797 if (state.failed) return ; 3798 dbg.location(547,9); 3799 pushFollow(FOLLOW_type_in_fieldDeclaration2034); 3800 type(); 3801 3802 state._fsp--; 3803 if (state.failed) return ; 3804 dbg.location(548,9); 3805 pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2044); 3806 variableDeclarator(); 3807 3808 state._fsp--; 3809 if (state.failed) return ; 3810 dbg.location(549,9); 3811 // src/com/google/doclava/parser/Java.g:549:9: ( ',' variableDeclarator )* 3812 try { dbg.enterSubRule(50); 3813 3814 loop50: 3815 do { 3816 int alt50=2; 3817 try { dbg.enterDecision(50, decisionCanBacktrack[50]); 3818 3819 int LA50_0 = input.LA(1); 3820 3821 if ( (LA50_0==COMMA) ) { 3822 alt50=1; 3823 } 3824 3825 3826 } finally {dbg.exitDecision(50);} 3827 3828 switch (alt50) { 3829 case 1 : 3830 dbg.enterAlt(1); 3831 3832 // src/com/google/doclava/parser/Java.g:549:10: ',' variableDeclarator 3833 { 3834 dbg.location(549,10); 3835 match(input,COMMA,FOLLOW_COMMA_in_fieldDeclaration2055); if (state.failed) return ; 3836 dbg.location(549,14); 3837 pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2057); 3838 variableDeclarator(); 3839 3840 state._fsp--; 3841 if (state.failed) return ; 3842 3843 } 3844 break; 3845 3846 default : 3847 break loop50; 3848 } 3849 } while (true); 3850 } finally {dbg.exitSubRule(50);} 3851 3852 dbg.location(551,9); 3853 match(input,SEMI,FOLLOW_SEMI_in_fieldDeclaration2078); if (state.failed) return ; 3854 3855 } 3856 3857 } 3858 catch (RecognitionException re) { 3859 reportError(re); 3860 recover(input,re); 3861 } 3862 finally { 3863 if ( state.backtracking>0 ) { memoize(input, 27, fieldDeclaration_StartIndex); } 3864 } 3865 dbg.location(552, 5); 3866 3867 } 3868 finally { 3869 dbg.exitRule(getGrammarFileName(), "fieldDeclaration"); 3870 decRuleLevel(); 3871 if ( getRuleLevel()==0 ) {dbg.terminate();} 3872 } 3873 3874 return ; 3875 } 3876 // $ANTLR end "fieldDeclaration" 3877 3878 3879 // $ANTLR start "variableDeclarator" 3880 // src/com/google/doclava/parser/Java.g:554:1: variableDeclarator : IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? ; variableDeclarator()3881 public final void variableDeclarator() throws RecognitionException { 3882 int variableDeclarator_StartIndex = input.index(); 3883 try { dbg.enterRule(getGrammarFileName(), "variableDeclarator"); 3884 if ( getRuleLevel()==0 ) {dbg.commence();} 3885 incRuleLevel(); 3886 dbg.location(554, 1); 3887 3888 try { 3889 if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return ; } 3890 // src/com/google/doclava/parser/Java.g:555:5: ( IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? ) 3891 dbg.enterAlt(1); 3892 3893 // src/com/google/doclava/parser/Java.g:555:9: IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? 3894 { 3895 dbg.location(555,9); 3896 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclarator2097); if (state.failed) return ; 3897 dbg.location(556,9); 3898 // src/com/google/doclava/parser/Java.g:556:9: ( '[' ']' )* 3899 try { dbg.enterSubRule(51); 3900 3901 loop51: 3902 do { 3903 int alt51=2; 3904 try { dbg.enterDecision(51, decisionCanBacktrack[51]); 3905 3906 int LA51_0 = input.LA(1); 3907 3908 if ( (LA51_0==LBRACKET) ) { 3909 alt51=1; 3910 } 3911 3912 3913 } finally {dbg.exitDecision(51);} 3914 3915 switch (alt51) { 3916 case 1 : 3917 dbg.enterAlt(1); 3918 3919 // src/com/google/doclava/parser/Java.g:556:10: '[' ']' 3920 { 3921 dbg.location(556,10); 3922 match(input,LBRACKET,FOLLOW_LBRACKET_in_variableDeclarator2108); if (state.failed) return ; 3923 dbg.location(556,14); 3924 match(input,RBRACKET,FOLLOW_RBRACKET_in_variableDeclarator2110); if (state.failed) return ; 3925 3926 } 3927 break; 3928 3929 default : 3930 break loop51; 3931 } 3932 } while (true); 3933 } finally {dbg.exitSubRule(51);} 3934 3935 dbg.location(558,9); 3936 // src/com/google/doclava/parser/Java.g:558:9: ( '=' variableInitializer )? 3937 int alt52=2; 3938 try { dbg.enterSubRule(52); 3939 try { dbg.enterDecision(52, decisionCanBacktrack[52]); 3940 3941 int LA52_0 = input.LA(1); 3942 3943 if ( (LA52_0==EQ) ) { 3944 alt52=1; 3945 } 3946 } finally {dbg.exitDecision(52);} 3947 3948 switch (alt52) { 3949 case 1 : 3950 dbg.enterAlt(1); 3951 3952 // src/com/google/doclava/parser/Java.g:558:10: '=' variableInitializer 3953 { 3954 dbg.location(558,10); 3955 match(input,EQ,FOLLOW_EQ_in_variableDeclarator2132); if (state.failed) return ; 3956 dbg.location(558,14); 3957 pushFollow(FOLLOW_variableInitializer_in_variableDeclarator2134); 3958 variableInitializer(); 3959 3960 state._fsp--; 3961 if (state.failed) return ; 3962 3963 } 3964 break; 3965 3966 } 3967 } finally {dbg.exitSubRule(52);} 3968 3969 3970 } 3971 3972 } 3973 catch (RecognitionException re) { 3974 reportError(re); 3975 recover(input,re); 3976 } 3977 finally { 3978 if ( state.backtracking>0 ) { memoize(input, 28, variableDeclarator_StartIndex); } 3979 } 3980 dbg.location(560, 5); 3981 3982 } 3983 finally { 3984 dbg.exitRule(getGrammarFileName(), "variableDeclarator"); 3985 decRuleLevel(); 3986 if ( getRuleLevel()==0 ) {dbg.terminate();} 3987 } 3988 3989 return ; 3990 } 3991 // $ANTLR end "variableDeclarator" 3992 3993 3994 // $ANTLR start "interfaceBodyDeclaration" 3995 // src/com/google/doclava/parser/Java.g:562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' ); interfaceBodyDeclaration()3996 public final void interfaceBodyDeclaration() throws RecognitionException { 3997 int interfaceBodyDeclaration_StartIndex = input.index(); 3998 try { dbg.enterRule(getGrammarFileName(), "interfaceBodyDeclaration"); 3999 if ( getRuleLevel()==0 ) {dbg.commence();} 4000 incRuleLevel(); 4001 dbg.location(562, 1); 4002 4003 try { 4004 if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; } 4005 // src/com/google/doclava/parser/Java.g:566:5: ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' ) 4006 int alt53=5; 4007 try { dbg.enterDecision(53, decisionCanBacktrack[53]); 4008 4009 try { 4010 isCyclicDecision = true; 4011 alt53 = dfa53.predict(input); 4012 } 4013 catch (NoViableAltException nvae) { 4014 dbg.recognitionException(nvae); 4015 throw nvae; 4016 } 4017 } finally {dbg.exitDecision(53);} 4018 4019 switch (alt53) { 4020 case 1 : 4021 dbg.enterAlt(1); 4022 4023 // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration 4024 { 4025 dbg.location(567,9); 4026 pushFollow(FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172); 4027 interfaceFieldDeclaration(); 4028 4029 state._fsp--; 4030 if (state.failed) return ; 4031 4032 } 4033 break; 4034 case 2 : 4035 dbg.enterAlt(2); 4036 4037 // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration 4038 { 4039 dbg.location(568,9); 4040 pushFollow(FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182); 4041 interfaceMethodDeclaration(); 4042 4043 state._fsp--; 4044 if (state.failed) return ; 4045 4046 } 4047 break; 4048 case 3 : 4049 dbg.enterAlt(3); 4050 4051 // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration 4052 { 4053 dbg.location(569,9); 4054 pushFollow(FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192); 4055 interfaceDeclaration(); 4056 4057 state._fsp--; 4058 if (state.failed) return ; 4059 4060 } 4061 break; 4062 case 4 : 4063 dbg.enterAlt(4); 4064 4065 // src/com/google/doclava/parser/Java.g:570:9: classDeclaration 4066 { 4067 dbg.location(570,9); 4068 pushFollow(FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202); 4069 classDeclaration(); 4070 4071 state._fsp--; 4072 if (state.failed) return ; 4073 4074 } 4075 break; 4076 case 5 : 4077 dbg.enterAlt(5); 4078 4079 // src/com/google/doclava/parser/Java.g:571:9: ';' 4080 { 4081 dbg.location(571,9); 4082 match(input,SEMI,FOLLOW_SEMI_in_interfaceBodyDeclaration2212); if (state.failed) return ; 4083 4084 } 4085 break; 4086 4087 } 4088 } 4089 catch (RecognitionException re) { 4090 reportError(re); 4091 recover(input,re); 4092 } 4093 finally { 4094 if ( state.backtracking>0 ) { memoize(input, 29, interfaceBodyDeclaration_StartIndex); } 4095 } 4096 dbg.location(572, 5); 4097 4098 } 4099 finally { 4100 dbg.exitRule(getGrammarFileName(), "interfaceBodyDeclaration"); 4101 decRuleLevel(); 4102 if ( getRuleLevel()==0 ) {dbg.terminate();} 4103 } 4104 4105 return ; 4106 } 4107 // $ANTLR end "interfaceBodyDeclaration" 4108 4109 4110 // $ANTLR start "interfaceMethodDeclaration" 4111 // src/com/google/doclava/parser/Java.g:574:1: interfaceMethodDeclaration : modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' ; interfaceMethodDeclaration()4112 public final void interfaceMethodDeclaration() throws RecognitionException { 4113 int interfaceMethodDeclaration_StartIndex = input.index(); 4114 try { dbg.enterRule(getGrammarFileName(), "interfaceMethodDeclaration"); 4115 if ( getRuleLevel()==0 ) {dbg.commence();} 4116 incRuleLevel(); 4117 dbg.location(574, 1); 4118 4119 try { 4120 if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; } 4121 // src/com/google/doclava/parser/Java.g:575:5: ( modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' ) 4122 dbg.enterAlt(1); 4123 4124 // src/com/google/doclava/parser/Java.g:575:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' 4125 { 4126 dbg.location(575,9); 4127 pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration2231); 4128 modifiers(); 4129 4130 state._fsp--; 4131 if (state.failed) return ; 4132 dbg.location(576,9); 4133 // src/com/google/doclava/parser/Java.g:576:9: ( typeParameters )? 4134 int alt54=2; 4135 try { dbg.enterSubRule(54); 4136 try { dbg.enterDecision(54, decisionCanBacktrack[54]); 4137 4138 int LA54_0 = input.LA(1); 4139 4140 if ( (LA54_0==LT) ) { 4141 alt54=1; 4142 } 4143 } finally {dbg.exitDecision(54);} 4144 4145 switch (alt54) { 4146 case 1 : 4147 dbg.enterAlt(1); 4148 4149 // src/com/google/doclava/parser/Java.g:576:10: typeParameters 4150 { 4151 dbg.location(576,10); 4152 pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration2242); 4153 typeParameters(); 4154 4155 state._fsp--; 4156 if (state.failed) return ; 4157 4158 } 4159 break; 4160 4161 } 4162 } finally {dbg.exitSubRule(54);} 4163 4164 dbg.location(578,9); 4165 // src/com/google/doclava/parser/Java.g:578:9: ( type | 'void' ) 4166 int alt55=2; 4167 try { dbg.enterSubRule(55); 4168 try { dbg.enterDecision(55, decisionCanBacktrack[55]); 4169 4170 int LA55_0 = input.LA(1); 4171 4172 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) ) { 4173 alt55=1; 4174 } 4175 else if ( (LA55_0==VOID) ) { 4176 alt55=2; 4177 } 4178 else { 4179 if (state.backtracking>0) {state.failed=true; return ;} 4180 NoViableAltException nvae = 4181 new NoViableAltException("", 55, 0, input); 4182 4183 dbg.recognitionException(nvae); 4184 throw nvae; 4185 } 4186 } finally {dbg.exitDecision(55);} 4187 4188 switch (alt55) { 4189 case 1 : 4190 dbg.enterAlt(1); 4191 4192 // src/com/google/doclava/parser/Java.g:578:10: type 4193 { 4194 dbg.location(578,10); 4195 pushFollow(FOLLOW_type_in_interfaceMethodDeclaration2264); 4196 type(); 4197 4198 state._fsp--; 4199 if (state.failed) return ; 4200 4201 } 4202 break; 4203 case 2 : 4204 dbg.enterAlt(2); 4205 4206 // src/com/google/doclava/parser/Java.g:579:10: 'void' 4207 { 4208 dbg.location(579,10); 4209 match(input,VOID,FOLLOW_VOID_in_interfaceMethodDeclaration2275); if (state.failed) return ; 4210 4211 } 4212 break; 4213 4214 } 4215 } finally {dbg.exitSubRule(55);} 4216 4217 dbg.location(581,9); 4218 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295); if (state.failed) return ; 4219 dbg.location(582,9); 4220 pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration2305); 4221 formalParameters(); 4222 4223 state._fsp--; 4224 if (state.failed) return ; 4225 dbg.location(583,9); 4226 // src/com/google/doclava/parser/Java.g:583:9: ( '[' ']' )* 4227 try { dbg.enterSubRule(56); 4228 4229 loop56: 4230 do { 4231 int alt56=2; 4232 try { dbg.enterDecision(56, decisionCanBacktrack[56]); 4233 4234 int LA56_0 = input.LA(1); 4235 4236 if ( (LA56_0==LBRACKET) ) { 4237 alt56=1; 4238 } 4239 4240 4241 } finally {dbg.exitDecision(56);} 4242 4243 switch (alt56) { 4244 case 1 : 4245 dbg.enterAlt(1); 4246 4247 // src/com/google/doclava/parser/Java.g:583:10: '[' ']' 4248 { 4249 dbg.location(583,10); 4250 match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316); if (state.failed) return ; 4251 dbg.location(583,14); 4252 match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318); if (state.failed) return ; 4253 4254 } 4255 break; 4256 4257 default : 4258 break loop56; 4259 } 4260 } while (true); 4261 } finally {dbg.exitSubRule(56);} 4262 4263 dbg.location(585,9); 4264 // src/com/google/doclava/parser/Java.g:585:9: ( 'throws' qualifiedNameList )? 4265 int alt57=2; 4266 try { dbg.enterSubRule(57); 4267 try { dbg.enterDecision(57, decisionCanBacktrack[57]); 4268 4269 int LA57_0 = input.LA(1); 4270 4271 if ( (LA57_0==THROWS) ) { 4272 alt57=1; 4273 } 4274 } finally {dbg.exitDecision(57);} 4275 4276 switch (alt57) { 4277 case 1 : 4278 dbg.enterAlt(1); 4279 4280 // src/com/google/doclava/parser/Java.g:585:10: 'throws' qualifiedNameList 4281 { 4282 dbg.location(585,10); 4283 match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration2340); if (state.failed) return ; 4284 dbg.location(585,19); 4285 pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342); 4286 qualifiedNameList(); 4287 4288 state._fsp--; 4289 if (state.failed) return ; 4290 4291 } 4292 break; 4293 4294 } 4295 } finally {dbg.exitSubRule(57);} 4296 4297 dbg.location(586,12); 4298 match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration2355); if (state.failed) return ; 4299 4300 } 4301 4302 } 4303 catch (RecognitionException re) { 4304 reportError(re); 4305 recover(input,re); 4306 } 4307 finally { 4308 if ( state.backtracking>0 ) { memoize(input, 30, interfaceMethodDeclaration_StartIndex); } 4309 } 4310 dbg.location(587, 5); 4311 4312 } 4313 finally { 4314 dbg.exitRule(getGrammarFileName(), "interfaceMethodDeclaration"); 4315 decRuleLevel(); 4316 if ( getRuleLevel()==0 ) {dbg.terminate();} 4317 } 4318 4319 return ; 4320 } 4321 // $ANTLR end "interfaceMethodDeclaration" 4322 4323 4324 // $ANTLR start "interfaceFieldDeclaration" 4325 // src/com/google/doclava/parser/Java.g:589:1: interfaceFieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ; interfaceFieldDeclaration()4326 public final void interfaceFieldDeclaration() throws RecognitionException { 4327 int interfaceFieldDeclaration_StartIndex = input.index(); 4328 try { dbg.enterRule(getGrammarFileName(), "interfaceFieldDeclaration"); 4329 if ( getRuleLevel()==0 ) {dbg.commence();} 4330 incRuleLevel(); 4331 dbg.location(589, 1); 4332 4333 try { 4334 if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; } 4335 // src/com/google/doclava/parser/Java.g:595:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ) 4336 dbg.enterAlt(1); 4337 4338 // src/com/google/doclava/parser/Java.g:595:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';' 4339 { 4340 dbg.location(595,9); 4341 pushFollow(FOLLOW_modifiers_in_interfaceFieldDeclaration2376); 4342 modifiers(); 4343 4344 state._fsp--; 4345 if (state.failed) return ; 4346 dbg.location(595,19); 4347 pushFollow(FOLLOW_type_in_interfaceFieldDeclaration2378); 4348 type(); 4349 4350 state._fsp--; 4351 if (state.failed) return ; 4352 dbg.location(595,24); 4353 pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380); 4354 variableDeclarator(); 4355 4356 state._fsp--; 4357 if (state.failed) return ; 4358 dbg.location(596,9); 4359 // src/com/google/doclava/parser/Java.g:596:9: ( ',' variableDeclarator )* 4360 try { dbg.enterSubRule(58); 4361 4362 loop58: 4363 do { 4364 int alt58=2; 4365 try { dbg.enterDecision(58, decisionCanBacktrack[58]); 4366 4367 int LA58_0 = input.LA(1); 4368 4369 if ( (LA58_0==COMMA) ) { 4370 alt58=1; 4371 } 4372 4373 4374 } finally {dbg.exitDecision(58);} 4375 4376 switch (alt58) { 4377 case 1 : 4378 dbg.enterAlt(1); 4379 4380 // src/com/google/doclava/parser/Java.g:596:10: ',' variableDeclarator 4381 { 4382 dbg.location(596,10); 4383 match(input,COMMA,FOLLOW_COMMA_in_interfaceFieldDeclaration2391); if (state.failed) return ; 4384 dbg.location(596,14); 4385 pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393); 4386 variableDeclarator(); 4387 4388 state._fsp--; 4389 if (state.failed) return ; 4390 4391 } 4392 break; 4393 4394 default : 4395 break loop58; 4396 } 4397 } while (true); 4398 } finally {dbg.exitSubRule(58);} 4399 4400 dbg.location(598,9); 4401 match(input,SEMI,FOLLOW_SEMI_in_interfaceFieldDeclaration2414); if (state.failed) return ; 4402 4403 } 4404 4405 } 4406 catch (RecognitionException re) { 4407 reportError(re); 4408 recover(input,re); 4409 } 4410 finally { 4411 if ( state.backtracking>0 ) { memoize(input, 31, interfaceFieldDeclaration_StartIndex); } 4412 } 4413 dbg.location(599, 5); 4414 4415 } 4416 finally { 4417 dbg.exitRule(getGrammarFileName(), "interfaceFieldDeclaration"); 4418 decRuleLevel(); 4419 if ( getRuleLevel()==0 ) {dbg.terminate();} 4420 } 4421 4422 return ; 4423 } 4424 // $ANTLR end "interfaceFieldDeclaration" 4425 4426 4427 // $ANTLR start "type" 4428 // src/com/google/doclava/parser/Java.g:602:1: type : ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* ); type()4429 public final void type() throws RecognitionException { 4430 int type_StartIndex = input.index(); 4431 try { dbg.enterRule(getGrammarFileName(), "type"); 4432 if ( getRuleLevel()==0 ) {dbg.commence();} 4433 incRuleLevel(); 4434 dbg.location(602, 1); 4435 4436 try { 4437 if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; } 4438 // src/com/google/doclava/parser/Java.g:603:5: ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* ) 4439 int alt61=2; 4440 try { dbg.enterDecision(61, decisionCanBacktrack[61]); 4441 4442 int LA61_0 = input.LA(1); 4443 4444 if ( (LA61_0==IDENTIFIER) ) { 4445 alt61=1; 4446 } 4447 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) ) { 4448 alt61=2; 4449 } 4450 else { 4451 if (state.backtracking>0) {state.failed=true; return ;} 4452 NoViableAltException nvae = 4453 new NoViableAltException("", 61, 0, input); 4454 4455 dbg.recognitionException(nvae); 4456 throw nvae; 4457 } 4458 } finally {dbg.exitDecision(61);} 4459 4460 switch (alt61) { 4461 case 1 : 4462 dbg.enterAlt(1); 4463 4464 // src/com/google/doclava/parser/Java.g:603:9: classOrInterfaceType ( '[' ']' )* 4465 { 4466 dbg.location(603,9); 4467 pushFollow(FOLLOW_classOrInterfaceType_in_type2434); 4468 classOrInterfaceType(); 4469 4470 state._fsp--; 4471 if (state.failed) return ; 4472 dbg.location(604,9); 4473 // src/com/google/doclava/parser/Java.g:604:9: ( '[' ']' )* 4474 try { dbg.enterSubRule(59); 4475 4476 loop59: 4477 do { 4478 int alt59=2; 4479 try { dbg.enterDecision(59, decisionCanBacktrack[59]); 4480 4481 int LA59_0 = input.LA(1); 4482 4483 if ( (LA59_0==LBRACKET) ) { 4484 alt59=1; 4485 } 4486 4487 4488 } finally {dbg.exitDecision(59);} 4489 4490 switch (alt59) { 4491 case 1 : 4492 dbg.enterAlt(1); 4493 4494 // src/com/google/doclava/parser/Java.g:604:10: '[' ']' 4495 { 4496 dbg.location(604,10); 4497 match(input,LBRACKET,FOLLOW_LBRACKET_in_type2445); if (state.failed) return ; 4498 dbg.location(604,14); 4499 match(input,RBRACKET,FOLLOW_RBRACKET_in_type2447); if (state.failed) return ; 4500 4501 } 4502 break; 4503 4504 default : 4505 break loop59; 4506 } 4507 } while (true); 4508 } finally {dbg.exitSubRule(59);} 4509 4510 4511 } 4512 break; 4513 case 2 : 4514 dbg.enterAlt(2); 4515 4516 // src/com/google/doclava/parser/Java.g:606:9: primitiveType ( '[' ']' )* 4517 { 4518 dbg.location(606,9); 4519 pushFollow(FOLLOW_primitiveType_in_type2468); 4520 primitiveType(); 4521 4522 state._fsp--; 4523 if (state.failed) return ; 4524 dbg.location(607,9); 4525 // src/com/google/doclava/parser/Java.g:607:9: ( '[' ']' )* 4526 try { dbg.enterSubRule(60); 4527 4528 loop60: 4529 do { 4530 int alt60=2; 4531 try { dbg.enterDecision(60, decisionCanBacktrack[60]); 4532 4533 int LA60_0 = input.LA(1); 4534 4535 if ( (LA60_0==LBRACKET) ) { 4536 alt60=1; 4537 } 4538 4539 4540 } finally {dbg.exitDecision(60);} 4541 4542 switch (alt60) { 4543 case 1 : 4544 dbg.enterAlt(1); 4545 4546 // src/com/google/doclava/parser/Java.g:607:10: '[' ']' 4547 { 4548 dbg.location(607,10); 4549 match(input,LBRACKET,FOLLOW_LBRACKET_in_type2479); if (state.failed) return ; 4550 dbg.location(607,14); 4551 match(input,RBRACKET,FOLLOW_RBRACKET_in_type2481); if (state.failed) return ; 4552 4553 } 4554 break; 4555 4556 default : 4557 break loop60; 4558 } 4559 } while (true); 4560 } finally {dbg.exitSubRule(60);} 4561 4562 4563 } 4564 break; 4565 4566 } 4567 } 4568 catch (RecognitionException re) { 4569 reportError(re); 4570 recover(input,re); 4571 } 4572 finally { 4573 if ( state.backtracking>0 ) { memoize(input, 32, type_StartIndex); } 4574 } 4575 dbg.location(609, 5); 4576 4577 } 4578 finally { 4579 dbg.exitRule(getGrammarFileName(), "type"); 4580 decRuleLevel(); 4581 if ( getRuleLevel()==0 ) {dbg.terminate();} 4582 } 4583 4584 return ; 4585 } 4586 // $ANTLR end "type" 4587 4588 4589 // $ANTLR start "classOrInterfaceType" 4590 // src/com/google/doclava/parser/Java.g:612:1: classOrInterfaceType : IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* ; classOrInterfaceType()4591 public final void classOrInterfaceType() throws RecognitionException { 4592 int classOrInterfaceType_StartIndex = input.index(); 4593 try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceType"); 4594 if ( getRuleLevel()==0 ) {dbg.commence();} 4595 incRuleLevel(); 4596 dbg.location(612, 1); 4597 4598 try { 4599 if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; } 4600 // src/com/google/doclava/parser/Java.g:613:5: ( IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* ) 4601 dbg.enterAlt(1); 4602 4603 // src/com/google/doclava/parser/Java.g:613:9: IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* 4604 { 4605 dbg.location(613,9); 4606 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2512); if (state.failed) return ; 4607 dbg.location(614,9); 4608 // src/com/google/doclava/parser/Java.g:614:9: ( typeArguments )? 4609 int alt62=2; 4610 try { dbg.enterSubRule(62); 4611 try { dbg.enterDecision(62, decisionCanBacktrack[62]); 4612 4613 int LA62_0 = input.LA(1); 4614 4615 if ( (LA62_0==LT) ) { 4616 int LA62_1 = input.LA(2); 4617 4618 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) ) { 4619 alt62=1; 4620 } 4621 } 4622 } finally {dbg.exitDecision(62);} 4623 4624 switch (alt62) { 4625 case 1 : 4626 dbg.enterAlt(1); 4627 4628 // src/com/google/doclava/parser/Java.g:614:10: typeArguments 4629 { 4630 dbg.location(614,10); 4631 pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2523); 4632 typeArguments(); 4633 4634 state._fsp--; 4635 if (state.failed) return ; 4636 4637 } 4638 break; 4639 4640 } 4641 } finally {dbg.exitSubRule(62);} 4642 4643 dbg.location(616,9); 4644 // src/com/google/doclava/parser/Java.g:616:9: ( '.' IDENTIFIER ( typeArguments )? )* 4645 try { dbg.enterSubRule(64); 4646 4647 loop64: 4648 do { 4649 int alt64=2; 4650 try { dbg.enterDecision(64, decisionCanBacktrack[64]); 4651 4652 int LA64_0 = input.LA(1); 4653 4654 if ( (LA64_0==DOT) ) { 4655 alt64=1; 4656 } 4657 4658 4659 } finally {dbg.exitDecision(64);} 4660 4661 switch (alt64) { 4662 case 1 : 4663 dbg.enterAlt(1); 4664 4665 // src/com/google/doclava/parser/Java.g:616:10: '.' IDENTIFIER ( typeArguments )? 4666 { 4667 dbg.location(616,10); 4668 match(input,DOT,FOLLOW_DOT_in_classOrInterfaceType2545); if (state.failed) return ; 4669 dbg.location(616,14); 4670 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2547); if (state.failed) return ; 4671 dbg.location(617,13); 4672 // src/com/google/doclava/parser/Java.g:617:13: ( typeArguments )? 4673 int alt63=2; 4674 try { dbg.enterSubRule(63); 4675 try { dbg.enterDecision(63, decisionCanBacktrack[63]); 4676 4677 int LA63_0 = input.LA(1); 4678 4679 if ( (LA63_0==LT) ) { 4680 int LA63_1 = input.LA(2); 4681 4682 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) ) { 4683 alt63=1; 4684 } 4685 } 4686 } finally {dbg.exitDecision(63);} 4687 4688 switch (alt63) { 4689 case 1 : 4690 dbg.enterAlt(1); 4691 4692 // src/com/google/doclava/parser/Java.g:617:14: typeArguments 4693 { 4694 dbg.location(617,14); 4695 pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2562); 4696 typeArguments(); 4697 4698 state._fsp--; 4699 if (state.failed) return ; 4700 4701 } 4702 break; 4703 4704 } 4705 } finally {dbg.exitSubRule(63);} 4706 4707 4708 } 4709 break; 4710 4711 default : 4712 break loop64; 4713 } 4714 } while (true); 4715 } finally {dbg.exitSubRule(64);} 4716 4717 4718 } 4719 4720 } 4721 catch (RecognitionException re) { 4722 reportError(re); 4723 recover(input,re); 4724 } 4725 finally { 4726 if ( state.backtracking>0 ) { memoize(input, 33, classOrInterfaceType_StartIndex); } 4727 } 4728 dbg.location(620, 5); 4729 4730 } 4731 finally { 4732 dbg.exitRule(getGrammarFileName(), "classOrInterfaceType"); 4733 decRuleLevel(); 4734 if ( getRuleLevel()==0 ) {dbg.terminate();} 4735 } 4736 4737 return ; 4738 } 4739 // $ANTLR end "classOrInterfaceType" 4740 4741 4742 // $ANTLR start "primitiveType" 4743 // src/com/google/doclava/parser/Java.g:622:1: primitiveType : ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' ); primitiveType()4744 public final void primitiveType() throws RecognitionException { 4745 int primitiveType_StartIndex = input.index(); 4746 try { dbg.enterRule(getGrammarFileName(), "primitiveType"); 4747 if ( getRuleLevel()==0 ) {dbg.commence();} 4748 incRuleLevel(); 4749 dbg.location(622, 1); 4750 4751 try { 4752 if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; } 4753 // src/com/google/doclava/parser/Java.g:623:5: ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' ) 4754 dbg.enterAlt(1); 4755 4756 // src/com/google/doclava/parser/Java.g: 4757 { 4758 dbg.location(623,5); 4759 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 ) { 4760 input.consume(); 4761 state.errorRecovery=false;state.failed=false; 4762 } 4763 else { 4764 if (state.backtracking>0) {state.failed=true; return ;} 4765 MismatchedSetException mse = new MismatchedSetException(null,input); 4766 dbg.recognitionException(mse); 4767 throw mse; 4768 } 4769 4770 4771 } 4772 4773 } 4774 catch (RecognitionException re) { 4775 reportError(re); 4776 recover(input,re); 4777 } 4778 finally { 4779 if ( state.backtracking>0 ) { memoize(input, 34, primitiveType_StartIndex); } 4780 } 4781 dbg.location(631, 5); 4782 4783 } 4784 finally { 4785 dbg.exitRule(getGrammarFileName(), "primitiveType"); 4786 decRuleLevel(); 4787 if ( getRuleLevel()==0 ) {dbg.terminate();} 4788 } 4789 4790 return ; 4791 } 4792 // $ANTLR end "primitiveType" 4793 4794 4795 // $ANTLR start "typeArguments" 4796 // src/com/google/doclava/parser/Java.g:633:1: typeArguments : '<' typeArgument ( ',' typeArgument )* '>' ; typeArguments()4797 public final void typeArguments() throws RecognitionException { 4798 int typeArguments_StartIndex = input.index(); 4799 try { dbg.enterRule(getGrammarFileName(), "typeArguments"); 4800 if ( getRuleLevel()==0 ) {dbg.commence();} 4801 incRuleLevel(); 4802 dbg.location(633, 1); 4803 4804 try { 4805 if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; } 4806 // src/com/google/doclava/parser/Java.g:634:5: ( '<' typeArgument ( ',' typeArgument )* '>' ) 4807 dbg.enterAlt(1); 4808 4809 // src/com/google/doclava/parser/Java.g:634:9: '<' typeArgument ( ',' typeArgument )* '>' 4810 { 4811 dbg.location(634,9); 4812 match(input,LT,FOLLOW_LT_in_typeArguments2696); if (state.failed) return ; 4813 dbg.location(634,13); 4814 pushFollow(FOLLOW_typeArgument_in_typeArguments2698); 4815 typeArgument(); 4816 4817 state._fsp--; 4818 if (state.failed) return ; 4819 dbg.location(635,9); 4820 // src/com/google/doclava/parser/Java.g:635:9: ( ',' typeArgument )* 4821 try { dbg.enterSubRule(65); 4822 4823 loop65: 4824 do { 4825 int alt65=2; 4826 try { dbg.enterDecision(65, decisionCanBacktrack[65]); 4827 4828 int LA65_0 = input.LA(1); 4829 4830 if ( (LA65_0==COMMA) ) { 4831 alt65=1; 4832 } 4833 4834 4835 } finally {dbg.exitDecision(65);} 4836 4837 switch (alt65) { 4838 case 1 : 4839 dbg.enterAlt(1); 4840 4841 // src/com/google/doclava/parser/Java.g:635:10: ',' typeArgument 4842 { 4843 dbg.location(635,10); 4844 match(input,COMMA,FOLLOW_COMMA_in_typeArguments2709); if (state.failed) return ; 4845 dbg.location(635,14); 4846 pushFollow(FOLLOW_typeArgument_in_typeArguments2711); 4847 typeArgument(); 4848 4849 state._fsp--; 4850 if (state.failed) return ; 4851 4852 } 4853 break; 4854 4855 default : 4856 break loop65; 4857 } 4858 } while (true); 4859 } finally {dbg.exitSubRule(65);} 4860 4861 dbg.location(637,9); 4862 match(input,GT,FOLLOW_GT_in_typeArguments2732); if (state.failed) return ; 4863 4864 } 4865 4866 } 4867 catch (RecognitionException re) { 4868 reportError(re); 4869 recover(input,re); 4870 } 4871 finally { 4872 if ( state.backtracking>0 ) { memoize(input, 35, typeArguments_StartIndex); } 4873 } 4874 dbg.location(638, 5); 4875 4876 } 4877 finally { 4878 dbg.exitRule(getGrammarFileName(), "typeArguments"); 4879 decRuleLevel(); 4880 if ( getRuleLevel()==0 ) {dbg.terminate();} 4881 } 4882 4883 return ; 4884 } 4885 // $ANTLR end "typeArguments" 4886 4887 4888 // $ANTLR start "typeArgument" 4889 // src/com/google/doclava/parser/Java.g:640:1: typeArgument : ( type | '?' ( ( 'extends' | 'super' ) type )? ); typeArgument()4890 public final void typeArgument() throws RecognitionException { 4891 int typeArgument_StartIndex = input.index(); 4892 try { dbg.enterRule(getGrammarFileName(), "typeArgument"); 4893 if ( getRuleLevel()==0 ) {dbg.commence();} 4894 incRuleLevel(); 4895 dbg.location(640, 1); 4896 4897 try { 4898 if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; } 4899 // src/com/google/doclava/parser/Java.g:641:5: ( type | '?' ( ( 'extends' | 'super' ) type )? ) 4900 int alt67=2; 4901 try { dbg.enterDecision(67, decisionCanBacktrack[67]); 4902 4903 int LA67_0 = input.LA(1); 4904 4905 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) ) { 4906 alt67=1; 4907 } 4908 else if ( (LA67_0==QUES) ) { 4909 alt67=2; 4910 } 4911 else { 4912 if (state.backtracking>0) {state.failed=true; return ;} 4913 NoViableAltException nvae = 4914 new NoViableAltException("", 67, 0, input); 4915 4916 dbg.recognitionException(nvae); 4917 throw nvae; 4918 } 4919 } finally {dbg.exitDecision(67);} 4920 4921 switch (alt67) { 4922 case 1 : 4923 dbg.enterAlt(1); 4924 4925 // src/com/google/doclava/parser/Java.g:641:9: type 4926 { 4927 dbg.location(641,9); 4928 pushFollow(FOLLOW_type_in_typeArgument2751); 4929 type(); 4930 4931 state._fsp--; 4932 if (state.failed) return ; 4933 4934 } 4935 break; 4936 case 2 : 4937 dbg.enterAlt(2); 4938 4939 // src/com/google/doclava/parser/Java.g:642:9: '?' ( ( 'extends' | 'super' ) type )? 4940 { 4941 dbg.location(642,9); 4942 match(input,QUES,FOLLOW_QUES_in_typeArgument2761); if (state.failed) return ; 4943 dbg.location(643,9); 4944 // src/com/google/doclava/parser/Java.g:643:9: ( ( 'extends' | 'super' ) type )? 4945 int alt66=2; 4946 try { dbg.enterSubRule(66); 4947 try { dbg.enterDecision(66, decisionCanBacktrack[66]); 4948 4949 int LA66_0 = input.LA(1); 4950 4951 if ( (LA66_0==EXTENDS||LA66_0==SUPER) ) { 4952 alt66=1; 4953 } 4954 } finally {dbg.exitDecision(66);} 4955 4956 switch (alt66) { 4957 case 1 : 4958 dbg.enterAlt(1); 4959 4960 // src/com/google/doclava/parser/Java.g:644:13: ( 'extends' | 'super' ) type 4961 { 4962 dbg.location(644,13); 4963 if ( input.LA(1)==EXTENDS||input.LA(1)==SUPER ) { 4964 input.consume(); 4965 state.errorRecovery=false;state.failed=false; 4966 } 4967 else { 4968 if (state.backtracking>0) {state.failed=true; return ;} 4969 MismatchedSetException mse = new MismatchedSetException(null,input); 4970 dbg.recognitionException(mse); 4971 throw mse; 4972 } 4973 4974 dbg.location(647,13); 4975 pushFollow(FOLLOW_type_in_typeArgument2829); 4976 type(); 4977 4978 state._fsp--; 4979 if (state.failed) return ; 4980 4981 } 4982 break; 4983 4984 } 4985 } finally {dbg.exitSubRule(66);} 4986 4987 4988 } 4989 break; 4990 4991 } 4992 } 4993 catch (RecognitionException re) { 4994 reportError(re); 4995 recover(input,re); 4996 } 4997 finally { 4998 if ( state.backtracking>0 ) { memoize(input, 36, typeArgument_StartIndex); } 4999 } 5000 dbg.location(649, 5); 5001 5002 } 5003 finally { 5004 dbg.exitRule(getGrammarFileName(), "typeArgument"); 5005 decRuleLevel(); 5006 if ( getRuleLevel()==0 ) {dbg.terminate();} 5007 } 5008 5009 return ; 5010 } 5011 // $ANTLR end "typeArgument" 5012 5013 5014 // $ANTLR start "qualifiedNameList" 5015 // src/com/google/doclava/parser/Java.g:651:1: qualifiedNameList : qualifiedName ( ',' qualifiedName )* ; qualifiedNameList()5016 public final void qualifiedNameList() throws RecognitionException { 5017 int qualifiedNameList_StartIndex = input.index(); 5018 try { dbg.enterRule(getGrammarFileName(), "qualifiedNameList"); 5019 if ( getRuleLevel()==0 ) {dbg.commence();} 5020 incRuleLevel(); 5021 dbg.location(651, 1); 5022 5023 try { 5024 if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; } 5025 // src/com/google/doclava/parser/Java.g:652:5: ( qualifiedName ( ',' qualifiedName )* ) 5026 dbg.enterAlt(1); 5027 5028 // src/com/google/doclava/parser/Java.g:652:9: qualifiedName ( ',' qualifiedName )* 5029 { 5030 dbg.location(652,9); 5031 pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2859); 5032 qualifiedName(); 5033 5034 state._fsp--; 5035 if (state.failed) return ; 5036 dbg.location(653,9); 5037 // src/com/google/doclava/parser/Java.g:653:9: ( ',' qualifiedName )* 5038 try { dbg.enterSubRule(68); 5039 5040 loop68: 5041 do { 5042 int alt68=2; 5043 try { dbg.enterDecision(68, decisionCanBacktrack[68]); 5044 5045 int LA68_0 = input.LA(1); 5046 5047 if ( (LA68_0==COMMA) ) { 5048 alt68=1; 5049 } 5050 5051 5052 } finally {dbg.exitDecision(68);} 5053 5054 switch (alt68) { 5055 case 1 : 5056 dbg.enterAlt(1); 5057 5058 // src/com/google/doclava/parser/Java.g:653:10: ',' qualifiedName 5059 { 5060 dbg.location(653,10); 5061 match(input,COMMA,FOLLOW_COMMA_in_qualifiedNameList2870); if (state.failed) return ; 5062 dbg.location(653,14); 5063 pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2872); 5064 qualifiedName(); 5065 5066 state._fsp--; 5067 if (state.failed) return ; 5068 5069 } 5070 break; 5071 5072 default : 5073 break loop68; 5074 } 5075 } while (true); 5076 } finally {dbg.exitSubRule(68);} 5077 5078 5079 } 5080 5081 } 5082 catch (RecognitionException re) { 5083 reportError(re); 5084 recover(input,re); 5085 } 5086 finally { 5087 if ( state.backtracking>0 ) { memoize(input, 37, qualifiedNameList_StartIndex); } 5088 } 5089 dbg.location(655, 5); 5090 5091 } 5092 finally { 5093 dbg.exitRule(getGrammarFileName(), "qualifiedNameList"); 5094 decRuleLevel(); 5095 if ( getRuleLevel()==0 ) {dbg.terminate();} 5096 } 5097 5098 return ; 5099 } 5100 // $ANTLR end "qualifiedNameList" 5101 5102 5103 // $ANTLR start "formalParameters" 5104 // src/com/google/doclava/parser/Java.g:657:1: formalParameters : '(' ( formalParameterDecls )? ')' ; formalParameters()5105 public final void formalParameters() throws RecognitionException { 5106 int formalParameters_StartIndex = input.index(); 5107 try { dbg.enterRule(getGrammarFileName(), "formalParameters"); 5108 if ( getRuleLevel()==0 ) {dbg.commence();} 5109 incRuleLevel(); 5110 dbg.location(657, 1); 5111 5112 try { 5113 if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; } 5114 // src/com/google/doclava/parser/Java.g:658:5: ( '(' ( formalParameterDecls )? ')' ) 5115 dbg.enterAlt(1); 5116 5117 // src/com/google/doclava/parser/Java.g:658:9: '(' ( formalParameterDecls )? ')' 5118 { 5119 dbg.location(658,9); 5120 match(input,LPAREN,FOLLOW_LPAREN_in_formalParameters2902); if (state.failed) return ; 5121 dbg.location(659,9); 5122 // src/com/google/doclava/parser/Java.g:659:9: ( formalParameterDecls )? 5123 int alt69=2; 5124 try { dbg.enterSubRule(69); 5125 try { dbg.enterDecision(69, decisionCanBacktrack[69]); 5126 5127 int LA69_0 = input.LA(1); 5128 5129 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) ) { 5130 alt69=1; 5131 } 5132 } finally {dbg.exitDecision(69);} 5133 5134 switch (alt69) { 5135 case 1 : 5136 dbg.enterAlt(1); 5137 5138 // src/com/google/doclava/parser/Java.g:659:10: formalParameterDecls 5139 { 5140 dbg.location(659,10); 5141 pushFollow(FOLLOW_formalParameterDecls_in_formalParameters2913); 5142 formalParameterDecls(); 5143 5144 state._fsp--; 5145 if (state.failed) return ; 5146 5147 } 5148 break; 5149 5150 } 5151 } finally {dbg.exitSubRule(69);} 5152 5153 dbg.location(661,9); 5154 match(input,RPAREN,FOLLOW_RPAREN_in_formalParameters2934); if (state.failed) return ; 5155 5156 } 5157 5158 } 5159 catch (RecognitionException re) { 5160 reportError(re); 5161 recover(input,re); 5162 } 5163 finally { 5164 if ( state.backtracking>0 ) { memoize(input, 38, formalParameters_StartIndex); } 5165 } 5166 dbg.location(662, 5); 5167 5168 } 5169 finally { 5170 dbg.exitRule(getGrammarFileName(), "formalParameters"); 5171 decRuleLevel(); 5172 if ( getRuleLevel()==0 ) {dbg.terminate();} 5173 } 5174 5175 return ; 5176 } 5177 // $ANTLR end "formalParameters" 5178 5179 5180 // $ANTLR start "formalParameterDecls" 5181 // src/com/google/doclava/parser/Java.g:664:1: formalParameterDecls : ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl ); formalParameterDecls()5182 public final void formalParameterDecls() throws RecognitionException { 5183 int formalParameterDecls_StartIndex = input.index(); 5184 try { dbg.enterRule(getGrammarFileName(), "formalParameterDecls"); 5185 if ( getRuleLevel()==0 ) {dbg.commence();} 5186 incRuleLevel(); 5187 dbg.location(664, 1); 5188 5189 try { 5190 if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; } 5191 // src/com/google/doclava/parser/Java.g:665:5: ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl ) 5192 int alt72=3; 5193 try { dbg.enterDecision(72, decisionCanBacktrack[72]); 5194 5195 switch ( input.LA(1) ) { 5196 case FINAL: 5197 { 5198 int LA72_1 = input.LA(2); 5199 5200 if ( (synpred96_Java()) ) { 5201 alt72=1; 5202 } 5203 else if ( (synpred98_Java()) ) { 5204 alt72=2; 5205 } 5206 else if ( (true) ) { 5207 alt72=3; 5208 } 5209 else { 5210 if (state.backtracking>0) {state.failed=true; return ;} 5211 NoViableAltException nvae = 5212 new NoViableAltException("", 72, 1, input); 5213 5214 dbg.recognitionException(nvae); 5215 throw nvae; 5216 } 5217 } 5218 break; 5219 case MONKEYS_AT: 5220 { 5221 int LA72_2 = input.LA(2); 5222 5223 if ( (synpred96_Java()) ) { 5224 alt72=1; 5225 } 5226 else if ( (synpred98_Java()) ) { 5227 alt72=2; 5228 } 5229 else if ( (true) ) { 5230 alt72=3; 5231 } 5232 else { 5233 if (state.backtracking>0) {state.failed=true; return ;} 5234 NoViableAltException nvae = 5235 new NoViableAltException("", 72, 2, input); 5236 5237 dbg.recognitionException(nvae); 5238 throw nvae; 5239 } 5240 } 5241 break; 5242 case IDENTIFIER: 5243 { 5244 int LA72_3 = input.LA(2); 5245 5246 if ( (synpred96_Java()) ) { 5247 alt72=1; 5248 } 5249 else if ( (synpred98_Java()) ) { 5250 alt72=2; 5251 } 5252 else if ( (true) ) { 5253 alt72=3; 5254 } 5255 else { 5256 if (state.backtracking>0) {state.failed=true; return ;} 5257 NoViableAltException nvae = 5258 new NoViableAltException("", 72, 3, input); 5259 5260 dbg.recognitionException(nvae); 5261 throw nvae; 5262 } 5263 } 5264 break; 5265 case BOOLEAN: 5266 case BYTE: 5267 case CHAR: 5268 case DOUBLE: 5269 case FLOAT: 5270 case INT: 5271 case LONG: 5272 case SHORT: 5273 { 5274 int LA72_4 = input.LA(2); 5275 5276 if ( (synpred96_Java()) ) { 5277 alt72=1; 5278 } 5279 else if ( (synpred98_Java()) ) { 5280 alt72=2; 5281 } 5282 else if ( (true) ) { 5283 alt72=3; 5284 } 5285 else { 5286 if (state.backtracking>0) {state.failed=true; return ;} 5287 NoViableAltException nvae = 5288 new NoViableAltException("", 72, 4, input); 5289 5290 dbg.recognitionException(nvae); 5291 throw nvae; 5292 } 5293 } 5294 break; 5295 default: 5296 if (state.backtracking>0) {state.failed=true; return ;} 5297 NoViableAltException nvae = 5298 new NoViableAltException("", 72, 0, input); 5299 5300 dbg.recognitionException(nvae); 5301 throw nvae; 5302 } 5303 5304 } finally {dbg.exitDecision(72);} 5305 5306 switch (alt72) { 5307 case 1 : 5308 dbg.enterAlt(1); 5309 5310 // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl 5311 { 5312 dbg.location(665,9); 5313 pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953); 5314 ellipsisParameterDecl(); 5315 5316 state._fsp--; 5317 if (state.failed) return ; 5318 5319 } 5320 break; 5321 case 2 : 5322 dbg.enterAlt(2); 5323 5324 // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )* 5325 { 5326 dbg.location(666,9); 5327 pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2963); 5328 normalParameterDecl(); 5329 5330 state._fsp--; 5331 if (state.failed) return ; 5332 dbg.location(667,9); 5333 // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )* 5334 try { dbg.enterSubRule(70); 5335 5336 loop70: 5337 do { 5338 int alt70=2; 5339 try { dbg.enterDecision(70, decisionCanBacktrack[70]); 5340 5341 int LA70_0 = input.LA(1); 5342 5343 if ( (LA70_0==COMMA) ) { 5344 alt70=1; 5345 } 5346 5347 5348 } finally {dbg.exitDecision(70);} 5349 5350 switch (alt70) { 5351 case 1 : 5352 dbg.enterAlt(1); 5353 5354 // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl 5355 { 5356 dbg.location(667,10); 5357 match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls2974); if (state.failed) return ; 5358 dbg.location(667,14); 5359 pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2976); 5360 normalParameterDecl(); 5361 5362 state._fsp--; 5363 if (state.failed) return ; 5364 5365 } 5366 break; 5367 5368 default : 5369 break loop70; 5370 } 5371 } while (true); 5372 } finally {dbg.exitSubRule(70);} 5373 5374 5375 } 5376 break; 5377 case 3 : 5378 dbg.enterAlt(3); 5379 5380 // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+ ellipsisParameterDecl 5381 { 5382 dbg.location(669,9); 5383 // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+ 5384 int cnt71=0; 5385 try { dbg.enterSubRule(71); 5386 5387 loop71: 5388 do { 5389 int alt71=2; 5390 try { dbg.enterDecision(71, decisionCanBacktrack[71]); 5391 5392 switch ( input.LA(1) ) { 5393 case FINAL: 5394 { 5395 int LA71_1 = input.LA(2); 5396 5397 if ( (synpred99_Java()) ) { 5398 alt71=1; 5399 } 5400 5401 5402 } 5403 break; 5404 case MONKEYS_AT: 5405 { 5406 int LA71_2 = input.LA(2); 5407 5408 if ( (synpred99_Java()) ) { 5409 alt71=1; 5410 } 5411 5412 5413 } 5414 break; 5415 case IDENTIFIER: 5416 { 5417 int LA71_3 = input.LA(2); 5418 5419 if ( (synpred99_Java()) ) { 5420 alt71=1; 5421 } 5422 5423 5424 } 5425 break; 5426 case BOOLEAN: 5427 case BYTE: 5428 case CHAR: 5429 case DOUBLE: 5430 case FLOAT: 5431 case INT: 5432 case LONG: 5433 case SHORT: 5434 { 5435 int LA71_4 = input.LA(2); 5436 5437 if ( (synpred99_Java()) ) { 5438 alt71=1; 5439 } 5440 5441 5442 } 5443 break; 5444 5445 } 5446 5447 } finally {dbg.exitDecision(71);} 5448 5449 switch (alt71) { 5450 case 1 : 5451 dbg.enterAlt(1); 5452 5453 // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ',' 5454 { 5455 dbg.location(669,10); 5456 pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2998); 5457 normalParameterDecl(); 5458 5459 state._fsp--; 5460 if (state.failed) return ; 5461 dbg.location(670,9); 5462 match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls3008); if (state.failed) return ; 5463 5464 } 5465 break; 5466 5467 default : 5468 if ( cnt71 >= 1 ) break loop71; 5469 if (state.backtracking>0) {state.failed=true; return ;} 5470 EarlyExitException eee = 5471 new EarlyExitException(71, input); 5472 dbg.recognitionException(eee); 5473 5474 throw eee; 5475 } 5476 cnt71++; 5477 } while (true); 5478 } finally {dbg.exitSubRule(71);} 5479 5480 dbg.location(672,9); 5481 pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029); 5482 ellipsisParameterDecl(); 5483 5484 state._fsp--; 5485 if (state.failed) return ; 5486 5487 } 5488 break; 5489 5490 } 5491 } 5492 catch (RecognitionException re) { 5493 reportError(re); 5494 recover(input,re); 5495 } 5496 finally { 5497 if ( state.backtracking>0 ) { memoize(input, 39, formalParameterDecls_StartIndex); } 5498 } 5499 dbg.location(673, 5); 5500 5501 } 5502 finally { 5503 dbg.exitRule(getGrammarFileName(), "formalParameterDecls"); 5504 decRuleLevel(); 5505 if ( getRuleLevel()==0 ) {dbg.terminate();} 5506 } 5507 5508 return ; 5509 } 5510 // $ANTLR end "formalParameterDecls" 5511 5512 5513 // $ANTLR start "normalParameterDecl" 5514 // src/com/google/doclava/parser/Java.g:675:1: normalParameterDecl : variableModifiers type IDENTIFIER ( '[' ']' )* ; normalParameterDecl()5515 public final void normalParameterDecl() throws RecognitionException { 5516 int normalParameterDecl_StartIndex = input.index(); 5517 try { dbg.enterRule(getGrammarFileName(), "normalParameterDecl"); 5518 if ( getRuleLevel()==0 ) {dbg.commence();} 5519 incRuleLevel(); 5520 dbg.location(675, 1); 5521 5522 try { 5523 if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; } 5524 // src/com/google/doclava/parser/Java.g:676:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ) 5525 dbg.enterAlt(1); 5526 5527 // src/com/google/doclava/parser/Java.g:676:9: variableModifiers type IDENTIFIER ( '[' ']' )* 5528 { 5529 dbg.location(676,9); 5530 pushFollow(FOLLOW_variableModifiers_in_normalParameterDecl3048); 5531 variableModifiers(); 5532 5533 state._fsp--; 5534 if (state.failed) return ; 5535 dbg.location(676,27); 5536 pushFollow(FOLLOW_type_in_normalParameterDecl3050); 5537 type(); 5538 5539 state._fsp--; 5540 if (state.failed) return ; 5541 dbg.location(676,32); 5542 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalParameterDecl3052); if (state.failed) return ; 5543 dbg.location(677,9); 5544 // src/com/google/doclava/parser/Java.g:677:9: ( '[' ']' )* 5545 try { dbg.enterSubRule(73); 5546 5547 loop73: 5548 do { 5549 int alt73=2; 5550 try { dbg.enterDecision(73, decisionCanBacktrack[73]); 5551 5552 int LA73_0 = input.LA(1); 5553 5554 if ( (LA73_0==LBRACKET) ) { 5555 alt73=1; 5556 } 5557 5558 5559 } finally {dbg.exitDecision(73);} 5560 5561 switch (alt73) { 5562 case 1 : 5563 dbg.enterAlt(1); 5564 5565 // src/com/google/doclava/parser/Java.g:677:10: '[' ']' 5566 { 5567 dbg.location(677,10); 5568 match(input,LBRACKET,FOLLOW_LBRACKET_in_normalParameterDecl3063); if (state.failed) return ; 5569 dbg.location(677,14); 5570 match(input,RBRACKET,FOLLOW_RBRACKET_in_normalParameterDecl3065); if (state.failed) return ; 5571 5572 } 5573 break; 5574 5575 default : 5576 break loop73; 5577 } 5578 } while (true); 5579 } finally {dbg.exitSubRule(73);} 5580 5581 5582 } 5583 5584 } 5585 catch (RecognitionException re) { 5586 reportError(re); 5587 recover(input,re); 5588 } 5589 finally { 5590 if ( state.backtracking>0 ) { memoize(input, 40, normalParameterDecl_StartIndex); } 5591 } 5592 dbg.location(679, 5); 5593 5594 } 5595 finally { 5596 dbg.exitRule(getGrammarFileName(), "normalParameterDecl"); 5597 decRuleLevel(); 5598 if ( getRuleLevel()==0 ) {dbg.terminate();} 5599 } 5600 5601 return ; 5602 } 5603 // $ANTLR end "normalParameterDecl" 5604 5605 5606 // $ANTLR start "ellipsisParameterDecl" 5607 // src/com/google/doclava/parser/Java.g:681:1: ellipsisParameterDecl : variableModifiers type '...' IDENTIFIER ; ellipsisParameterDecl()5608 public final void ellipsisParameterDecl() throws RecognitionException { 5609 int ellipsisParameterDecl_StartIndex = input.index(); 5610 try { dbg.enterRule(getGrammarFileName(), "ellipsisParameterDecl"); 5611 if ( getRuleLevel()==0 ) {dbg.commence();} 5612 incRuleLevel(); 5613 dbg.location(681, 1); 5614 5615 try { 5616 if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; } 5617 // src/com/google/doclava/parser/Java.g:682:5: ( variableModifiers type '...' IDENTIFIER ) 5618 dbg.enterAlt(1); 5619 5620 // src/com/google/doclava/parser/Java.g:682:9: variableModifiers type '...' IDENTIFIER 5621 { 5622 dbg.location(682,9); 5623 pushFollow(FOLLOW_variableModifiers_in_ellipsisParameterDecl3095); 5624 variableModifiers(); 5625 5626 state._fsp--; 5627 if (state.failed) return ; 5628 dbg.location(683,9); 5629 pushFollow(FOLLOW_type_in_ellipsisParameterDecl3105); 5630 type(); 5631 5632 state._fsp--; 5633 if (state.failed) return ; 5634 dbg.location(683,15); 5635 match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108); if (state.failed) return ; 5636 dbg.location(684,9); 5637 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118); if (state.failed) return ; 5638 5639 } 5640 5641 } 5642 catch (RecognitionException re) { 5643 reportError(re); 5644 recover(input,re); 5645 } 5646 finally { 5647 if ( state.backtracking>0 ) { memoize(input, 41, ellipsisParameterDecl_StartIndex); } 5648 } 5649 dbg.location(685, 5); 5650 5651 } 5652 finally { 5653 dbg.exitRule(getGrammarFileName(), "ellipsisParameterDecl"); 5654 decRuleLevel(); 5655 if ( getRuleLevel()==0 ) {dbg.terminate();} 5656 } 5657 5658 return ; 5659 } 5660 // $ANTLR end "ellipsisParameterDecl" 5661 5662 5663 // $ANTLR start "explicitConstructorInvocation" 5664 // src/com/google/doclava/parser/Java.g:688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' ); explicitConstructorInvocation()5665 public final void explicitConstructorInvocation() throws RecognitionException { 5666 int explicitConstructorInvocation_StartIndex = input.index(); 5667 try { dbg.enterRule(getGrammarFileName(), "explicitConstructorInvocation"); 5668 if ( getRuleLevel()==0 ) {dbg.commence();} 5669 incRuleLevel(); 5670 dbg.location(688, 1); 5671 5672 try { 5673 if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; } 5674 // src/com/google/doclava/parser/Java.g:689:5: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' ) 5675 int alt76=2; 5676 try { dbg.enterDecision(76, decisionCanBacktrack[76]); 5677 5678 try { 5679 isCyclicDecision = true; 5680 alt76 = dfa76.predict(input); 5681 } 5682 catch (NoViableAltException nvae) { 5683 dbg.recognitionException(nvae); 5684 throw nvae; 5685 } 5686 } finally {dbg.exitDecision(76);} 5687 5688 switch (alt76) { 5689 case 1 : 5690 dbg.enterAlt(1); 5691 5692 // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' 5693 { 5694 dbg.location(689,9); 5695 // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? 5696 int alt74=2; 5697 try { dbg.enterSubRule(74); 5698 try { dbg.enterDecision(74, decisionCanBacktrack[74]); 5699 5700 int LA74_0 = input.LA(1); 5701 5702 if ( (LA74_0==LT) ) { 5703 alt74=1; 5704 } 5705 } finally {dbg.exitDecision(74);} 5706 5707 switch (alt74) { 5708 case 1 : 5709 dbg.enterAlt(1); 5710 5711 // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments 5712 { 5713 dbg.location(689,10); 5714 pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139); 5715 nonWildcardTypeArguments(); 5716 5717 state._fsp--; 5718 if (state.failed) return ; 5719 5720 } 5721 break; 5722 5723 } 5724 } finally {dbg.exitSubRule(74);} 5725 5726 dbg.location(691,9); 5727 if ( input.LA(1)==SUPER||input.LA(1)==THIS ) { 5728 input.consume(); 5729 state.errorRecovery=false;state.failed=false; 5730 } 5731 else { 5732 if (state.backtracking>0) {state.failed=true; return ;} 5733 MismatchedSetException mse = new MismatchedSetException(null,input); 5734 dbg.recognitionException(mse); 5735 throw mse; 5736 } 5737 5738 dbg.location(694,9); 5739 pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3197); 5740 arguments(); 5741 5742 state._fsp--; 5743 if (state.failed) return ; 5744 dbg.location(694,19); 5745 match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3199); if (state.failed) return ; 5746 5747 } 5748 break; 5749 case 2 : 5750 dbg.enterAlt(2); 5751 5752 // src/com/google/doclava/parser/Java.g:696:9: primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' 5753 { 5754 dbg.location(696,9); 5755 pushFollow(FOLLOW_primary_in_explicitConstructorInvocation3210); 5756 primary(); 5757 5758 state._fsp--; 5759 if (state.failed) return ; 5760 dbg.location(697,9); 5761 match(input,DOT,FOLLOW_DOT_in_explicitConstructorInvocation3220); if (state.failed) return ; 5762 dbg.location(698,9); 5763 // src/com/google/doclava/parser/Java.g:698:9: ( nonWildcardTypeArguments )? 5764 int alt75=2; 5765 try { dbg.enterSubRule(75); 5766 try { dbg.enterDecision(75, decisionCanBacktrack[75]); 5767 5768 int LA75_0 = input.LA(1); 5769 5770 if ( (LA75_0==LT) ) { 5771 alt75=1; 5772 } 5773 } finally {dbg.exitDecision(75);} 5774 5775 switch (alt75) { 5776 case 1 : 5777 dbg.enterAlt(1); 5778 5779 // src/com/google/doclava/parser/Java.g:698:10: nonWildcardTypeArguments 5780 { 5781 dbg.location(698,10); 5782 pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231); 5783 nonWildcardTypeArguments(); 5784 5785 state._fsp--; 5786 if (state.failed) return ; 5787 5788 } 5789 break; 5790 5791 } 5792 } finally {dbg.exitSubRule(75);} 5793 5794 dbg.location(700,9); 5795 match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation3252); if (state.failed) return ; 5796 dbg.location(701,9); 5797 pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3262); 5798 arguments(); 5799 5800 state._fsp--; 5801 if (state.failed) return ; 5802 dbg.location(701,19); 5803 match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3264); if (state.failed) return ; 5804 5805 } 5806 break; 5807 5808 } 5809 } 5810 catch (RecognitionException re) { 5811 reportError(re); 5812 recover(input,re); 5813 } 5814 finally { 5815 if ( state.backtracking>0 ) { memoize(input, 42, explicitConstructorInvocation_StartIndex); } 5816 } 5817 dbg.location(702, 5); 5818 5819 } 5820 finally { 5821 dbg.exitRule(getGrammarFileName(), "explicitConstructorInvocation"); 5822 decRuleLevel(); 5823 if ( getRuleLevel()==0 ) {dbg.terminate();} 5824 } 5825 5826 return ; 5827 } 5828 // $ANTLR end "explicitConstructorInvocation" 5829 5830 5831 // $ANTLR start "qualifiedName" 5832 // src/com/google/doclava/parser/Java.g:704:1: qualifiedName : IDENTIFIER ( '.' IDENTIFIER )* ; qualifiedName()5833 public final void qualifiedName() throws RecognitionException { 5834 int qualifiedName_StartIndex = input.index(); 5835 try { dbg.enterRule(getGrammarFileName(), "qualifiedName"); 5836 if ( getRuleLevel()==0 ) {dbg.commence();} 5837 incRuleLevel(); 5838 dbg.location(704, 1); 5839 5840 try { 5841 if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; } 5842 // src/com/google/doclava/parser/Java.g:705:5: ( IDENTIFIER ( '.' IDENTIFIER )* ) 5843 dbg.enterAlt(1); 5844 5845 // src/com/google/doclava/parser/Java.g:705:9: IDENTIFIER ( '.' IDENTIFIER )* 5846 { 5847 dbg.location(705,9); 5848 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3283); if (state.failed) return ; 5849 dbg.location(706,9); 5850 // src/com/google/doclava/parser/Java.g:706:9: ( '.' IDENTIFIER )* 5851 try { dbg.enterSubRule(77); 5852 5853 loop77: 5854 do { 5855 int alt77=2; 5856 try { dbg.enterDecision(77, decisionCanBacktrack[77]); 5857 5858 int LA77_0 = input.LA(1); 5859 5860 if ( (LA77_0==DOT) ) { 5861 alt77=1; 5862 } 5863 5864 5865 } finally {dbg.exitDecision(77);} 5866 5867 switch (alt77) { 5868 case 1 : 5869 dbg.enterAlt(1); 5870 5871 // src/com/google/doclava/parser/Java.g:706:10: '.' IDENTIFIER 5872 { 5873 dbg.location(706,10); 5874 match(input,DOT,FOLLOW_DOT_in_qualifiedName3294); if (state.failed) return ; 5875 dbg.location(706,14); 5876 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3296); if (state.failed) return ; 5877 5878 } 5879 break; 5880 5881 default : 5882 break loop77; 5883 } 5884 } while (true); 5885 } finally {dbg.exitSubRule(77);} 5886 5887 5888 } 5889 5890 } 5891 catch (RecognitionException re) { 5892 reportError(re); 5893 recover(input,re); 5894 } 5895 finally { 5896 if ( state.backtracking>0 ) { memoize(input, 43, qualifiedName_StartIndex); } 5897 } 5898 dbg.location(708, 5); 5899 5900 } 5901 finally { 5902 dbg.exitRule(getGrammarFileName(), "qualifiedName"); 5903 decRuleLevel(); 5904 if ( getRuleLevel()==0 ) {dbg.terminate();} 5905 } 5906 5907 return ; 5908 } 5909 // $ANTLR end "qualifiedName" 5910 5911 5912 // $ANTLR start "annotations" 5913 // src/com/google/doclava/parser/Java.g:710:1: annotations : ( annotation )+ ; annotations()5914 public final void annotations() throws RecognitionException { 5915 int annotations_StartIndex = input.index(); 5916 try { dbg.enterRule(getGrammarFileName(), "annotations"); 5917 if ( getRuleLevel()==0 ) {dbg.commence();} 5918 incRuleLevel(); 5919 dbg.location(710, 1); 5920 5921 try { 5922 if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; } 5923 // src/com/google/doclava/parser/Java.g:711:5: ( ( annotation )+ ) 5924 dbg.enterAlt(1); 5925 5926 // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+ 5927 { 5928 dbg.location(711,9); 5929 // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+ 5930 int cnt78=0; 5931 try { dbg.enterSubRule(78); 5932 5933 loop78: 5934 do { 5935 int alt78=2; 5936 try { dbg.enterDecision(78, decisionCanBacktrack[78]); 5937 5938 int LA78_0 = input.LA(1); 5939 5940 if ( (LA78_0==MONKEYS_AT) ) { 5941 alt78=1; 5942 } 5943 5944 5945 } finally {dbg.exitDecision(78);} 5946 5947 switch (alt78) { 5948 case 1 : 5949 dbg.enterAlt(1); 5950 5951 // src/com/google/doclava/parser/Java.g:711:10: annotation 5952 { 5953 dbg.location(711,10); 5954 pushFollow(FOLLOW_annotation_in_annotations3327); 5955 annotation(); 5956 5957 state._fsp--; 5958 if (state.failed) return ; 5959 5960 } 5961 break; 5962 5963 default : 5964 if ( cnt78 >= 1 ) break loop78; 5965 if (state.backtracking>0) {state.failed=true; return ;} 5966 EarlyExitException eee = 5967 new EarlyExitException(78, input); 5968 dbg.recognitionException(eee); 5969 5970 throw eee; 5971 } 5972 cnt78++; 5973 } while (true); 5974 } finally {dbg.exitSubRule(78);} 5975 5976 5977 } 5978 5979 } 5980 catch (RecognitionException re) { 5981 reportError(re); 5982 recover(input,re); 5983 } 5984 finally { 5985 if ( state.backtracking>0 ) { memoize(input, 44, annotations_StartIndex); } 5986 } 5987 dbg.location(713, 5); 5988 5989 } 5990 finally { 5991 dbg.exitRule(getGrammarFileName(), "annotations"); 5992 decRuleLevel(); 5993 if ( getRuleLevel()==0 ) {dbg.terminate();} 5994 } 5995 5996 return ; 5997 } 5998 // $ANTLR end "annotations" 5999 6000 6001 // $ANTLR start "annotation" 6002 // src/com/google/doclava/parser/Java.g:715:1: annotation : '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ; annotation()6003 public final void annotation() throws RecognitionException { 6004 int annotation_StartIndex = input.index(); 6005 try { dbg.enterRule(getGrammarFileName(), "annotation"); 6006 if ( getRuleLevel()==0 ) {dbg.commence();} 6007 incRuleLevel(); 6008 dbg.location(715, 1); 6009 6010 try { 6011 if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; } 6012 // src/com/google/doclava/parser/Java.g:720:5: ( '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ) 6013 dbg.enterAlt(1); 6014 6015 // src/com/google/doclava/parser/Java.g:720:9: '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? 6016 { 6017 dbg.location(720,9); 6018 match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotation3359); if (state.failed) return ; 6019 dbg.location(720,13); 6020 pushFollow(FOLLOW_qualifiedName_in_annotation3361); 6021 qualifiedName(); 6022 6023 state._fsp--; 6024 if (state.failed) return ; 6025 dbg.location(721,9); 6026 // src/com/google/doclava/parser/Java.g:721:9: ( '(' ( elementValuePairs | elementValue )? ')' )? 6027 int alt80=2; 6028 try { dbg.enterSubRule(80); 6029 try { dbg.enterDecision(80, decisionCanBacktrack[80]); 6030 6031 int LA80_0 = input.LA(1); 6032 6033 if ( (LA80_0==LPAREN) ) { 6034 alt80=1; 6035 } 6036 } finally {dbg.exitDecision(80);} 6037 6038 switch (alt80) { 6039 case 1 : 6040 dbg.enterAlt(1); 6041 6042 // src/com/google/doclava/parser/Java.g:721:13: '(' ( elementValuePairs | elementValue )? ')' 6043 { 6044 dbg.location(721,13); 6045 match(input,LPAREN,FOLLOW_LPAREN_in_annotation3375); if (state.failed) return ; 6046 dbg.location(722,19); 6047 // src/com/google/doclava/parser/Java.g:722:19: ( elementValuePairs | elementValue )? 6048 int alt79=3; 6049 try { dbg.enterSubRule(79); 6050 try { dbg.enterDecision(79, decisionCanBacktrack[79]); 6051 6052 int LA79_0 = input.LA(1); 6053 6054 if ( (LA79_0==IDENTIFIER) ) { 6055 int LA79_1 = input.LA(2); 6056 6057 if ( (LA79_1==EQ) ) { 6058 alt79=1; 6059 } 6060 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)) ) { 6061 alt79=2; 6062 } 6063 } 6064 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) ) { 6065 alt79=2; 6066 } 6067 } finally {dbg.exitDecision(79);} 6068 6069 switch (alt79) { 6070 case 1 : 6071 dbg.enterAlt(1); 6072 6073 // src/com/google/doclava/parser/Java.g:722:23: elementValuePairs 6074 { 6075 dbg.location(722,23); 6076 pushFollow(FOLLOW_elementValuePairs_in_annotation3399); 6077 elementValuePairs(); 6078 6079 state._fsp--; 6080 if (state.failed) return ; 6081 6082 } 6083 break; 6084 case 2 : 6085 dbg.enterAlt(2); 6086 6087 // src/com/google/doclava/parser/Java.g:723:23: elementValue 6088 { 6089 dbg.location(723,23); 6090 pushFollow(FOLLOW_elementValue_in_annotation3423); 6091 elementValue(); 6092 6093 state._fsp--; 6094 if (state.failed) return ; 6095 6096 } 6097 break; 6098 6099 } 6100 } finally {dbg.exitSubRule(79);} 6101 6102 dbg.location(725,13); 6103 match(input,RPAREN,FOLLOW_RPAREN_in_annotation3458); if (state.failed) return ; 6104 6105 } 6106 break; 6107 6108 } 6109 } finally {dbg.exitSubRule(80);} 6110 6111 6112 } 6113 6114 } 6115 catch (RecognitionException re) { 6116 reportError(re); 6117 recover(input,re); 6118 } 6119 finally { 6120 if ( state.backtracking>0 ) { memoize(input, 45, annotation_StartIndex); } 6121 } 6122 dbg.location(727, 5); 6123 6124 } 6125 finally { 6126 dbg.exitRule(getGrammarFileName(), "annotation"); 6127 decRuleLevel(); 6128 if ( getRuleLevel()==0 ) {dbg.terminate();} 6129 } 6130 6131 return ; 6132 } 6133 // $ANTLR end "annotation" 6134 6135 6136 // $ANTLR start "elementValuePairs" 6137 // src/com/google/doclava/parser/Java.g:729:1: elementValuePairs : elementValuePair ( ',' elementValuePair )* ; elementValuePairs()6138 public final void elementValuePairs() throws RecognitionException { 6139 int elementValuePairs_StartIndex = input.index(); 6140 try { dbg.enterRule(getGrammarFileName(), "elementValuePairs"); 6141 if ( getRuleLevel()==0 ) {dbg.commence();} 6142 incRuleLevel(); 6143 dbg.location(729, 1); 6144 6145 try { 6146 if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; } 6147 // src/com/google/doclava/parser/Java.g:730:5: ( elementValuePair ( ',' elementValuePair )* ) 6148 dbg.enterAlt(1); 6149 6150 // src/com/google/doclava/parser/Java.g:730:9: elementValuePair ( ',' elementValuePair )* 6151 { 6152 dbg.location(730,9); 6153 pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3488); 6154 elementValuePair(); 6155 6156 state._fsp--; 6157 if (state.failed) return ; 6158 dbg.location(731,9); 6159 // src/com/google/doclava/parser/Java.g:731:9: ( ',' elementValuePair )* 6160 try { dbg.enterSubRule(81); 6161 6162 loop81: 6163 do { 6164 int alt81=2; 6165 try { dbg.enterDecision(81, decisionCanBacktrack[81]); 6166 6167 int LA81_0 = input.LA(1); 6168 6169 if ( (LA81_0==COMMA) ) { 6170 alt81=1; 6171 } 6172 6173 6174 } finally {dbg.exitDecision(81);} 6175 6176 switch (alt81) { 6177 case 1 : 6178 dbg.enterAlt(1); 6179 6180 // src/com/google/doclava/parser/Java.g:731:10: ',' elementValuePair 6181 { 6182 dbg.location(731,10); 6183 match(input,COMMA,FOLLOW_COMMA_in_elementValuePairs3499); if (state.failed) return ; 6184 dbg.location(731,14); 6185 pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3501); 6186 elementValuePair(); 6187 6188 state._fsp--; 6189 if (state.failed) return ; 6190 6191 } 6192 break; 6193 6194 default : 6195 break loop81; 6196 } 6197 } while (true); 6198 } finally {dbg.exitSubRule(81);} 6199 6200 6201 } 6202 6203 } 6204 catch (RecognitionException re) { 6205 reportError(re); 6206 recover(input,re); 6207 } 6208 finally { 6209 if ( state.backtracking>0 ) { memoize(input, 46, elementValuePairs_StartIndex); } 6210 } 6211 dbg.location(733, 5); 6212 6213 } 6214 finally { 6215 dbg.exitRule(getGrammarFileName(), "elementValuePairs"); 6216 decRuleLevel(); 6217 if ( getRuleLevel()==0 ) {dbg.terminate();} 6218 } 6219 6220 return ; 6221 } 6222 // $ANTLR end "elementValuePairs" 6223 6224 6225 // $ANTLR start "elementValuePair" 6226 // src/com/google/doclava/parser/Java.g:735:1: elementValuePair : IDENTIFIER '=' elementValue ; elementValuePair()6227 public final void elementValuePair() throws RecognitionException { 6228 int elementValuePair_StartIndex = input.index(); 6229 try { dbg.enterRule(getGrammarFileName(), "elementValuePair"); 6230 if ( getRuleLevel()==0 ) {dbg.commence();} 6231 incRuleLevel(); 6232 dbg.location(735, 1); 6233 6234 try { 6235 if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; } 6236 // src/com/google/doclava/parser/Java.g:736:5: ( IDENTIFIER '=' elementValue ) 6237 dbg.enterAlt(1); 6238 6239 // src/com/google/doclava/parser/Java.g:736:9: IDENTIFIER '=' elementValue 6240 { 6241 dbg.location(736,9); 6242 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_elementValuePair3531); if (state.failed) return ; 6243 dbg.location(736,20); 6244 match(input,EQ,FOLLOW_EQ_in_elementValuePair3533); if (state.failed) return ; 6245 dbg.location(736,24); 6246 pushFollow(FOLLOW_elementValue_in_elementValuePair3535); 6247 elementValue(); 6248 6249 state._fsp--; 6250 if (state.failed) return ; 6251 6252 } 6253 6254 } 6255 catch (RecognitionException re) { 6256 reportError(re); 6257 recover(input,re); 6258 } 6259 finally { 6260 if ( state.backtracking>0 ) { memoize(input, 47, elementValuePair_StartIndex); } 6261 } 6262 dbg.location(737, 5); 6263 6264 } 6265 finally { 6266 dbg.exitRule(getGrammarFileName(), "elementValuePair"); 6267 decRuleLevel(); 6268 if ( getRuleLevel()==0 ) {dbg.terminate();} 6269 } 6270 6271 return ; 6272 } 6273 // $ANTLR end "elementValuePair" 6274 6275 6276 // $ANTLR start "elementValue" 6277 // src/com/google/doclava/parser/Java.g:739:1: elementValue : ( conditionalExpression | annotation | elementValueArrayInitializer ); elementValue()6278 public final void elementValue() throws RecognitionException { 6279 int elementValue_StartIndex = input.index(); 6280 try { dbg.enterRule(getGrammarFileName(), "elementValue"); 6281 if ( getRuleLevel()==0 ) {dbg.commence();} 6282 incRuleLevel(); 6283 dbg.location(739, 1); 6284 6285 try { 6286 if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; } 6287 // src/com/google/doclava/parser/Java.g:740:5: ( conditionalExpression | annotation | elementValueArrayInitializer ) 6288 int alt82=3; 6289 try { dbg.enterDecision(82, decisionCanBacktrack[82]); 6290 6291 switch ( input.LA(1) ) { 6292 case IDENTIFIER: 6293 case INTLITERAL: 6294 case LONGLITERAL: 6295 case FLOATLITERAL: 6296 case DOUBLELITERAL: 6297 case CHARLITERAL: 6298 case STRINGLITERAL: 6299 case TRUE: 6300 case FALSE: 6301 case NULL: 6302 case BOOLEAN: 6303 case BYTE: 6304 case CHAR: 6305 case DOUBLE: 6306 case FLOAT: 6307 case INT: 6308 case LONG: 6309 case NEW: 6310 case SHORT: 6311 case SUPER: 6312 case THIS: 6313 case VOID: 6314 case LPAREN: 6315 case BANG: 6316 case TILDE: 6317 case PLUSPLUS: 6318 case SUBSUB: 6319 case PLUS: 6320 case SUB: 6321 { 6322 alt82=1; 6323 } 6324 break; 6325 case MONKEYS_AT: 6326 { 6327 alt82=2; 6328 } 6329 break; 6330 case LBRACE: 6331 { 6332 alt82=3; 6333 } 6334 break; 6335 default: 6336 if (state.backtracking>0) {state.failed=true; return ;} 6337 NoViableAltException nvae = 6338 new NoViableAltException("", 82, 0, input); 6339 6340 dbg.recognitionException(nvae); 6341 throw nvae; 6342 } 6343 6344 } finally {dbg.exitDecision(82);} 6345 6346 switch (alt82) { 6347 case 1 : 6348 dbg.enterAlt(1); 6349 6350 // src/com/google/doclava/parser/Java.g:740:9: conditionalExpression 6351 { 6352 dbg.location(740,9); 6353 pushFollow(FOLLOW_conditionalExpression_in_elementValue3554); 6354 conditionalExpression(); 6355 6356 state._fsp--; 6357 if (state.failed) return ; 6358 6359 } 6360 break; 6361 case 2 : 6362 dbg.enterAlt(2); 6363 6364 // src/com/google/doclava/parser/Java.g:741:9: annotation 6365 { 6366 dbg.location(741,9); 6367 pushFollow(FOLLOW_annotation_in_elementValue3564); 6368 annotation(); 6369 6370 state._fsp--; 6371 if (state.failed) return ; 6372 6373 } 6374 break; 6375 case 3 : 6376 dbg.enterAlt(3); 6377 6378 // src/com/google/doclava/parser/Java.g:742:9: elementValueArrayInitializer 6379 { 6380 dbg.location(742,9); 6381 pushFollow(FOLLOW_elementValueArrayInitializer_in_elementValue3574); 6382 elementValueArrayInitializer(); 6383 6384 state._fsp--; 6385 if (state.failed) return ; 6386 6387 } 6388 break; 6389 6390 } 6391 } 6392 catch (RecognitionException re) { 6393 reportError(re); 6394 recover(input,re); 6395 } 6396 finally { 6397 if ( state.backtracking>0 ) { memoize(input, 48, elementValue_StartIndex); } 6398 } 6399 dbg.location(743, 5); 6400 6401 } 6402 finally { 6403 dbg.exitRule(getGrammarFileName(), "elementValue"); 6404 decRuleLevel(); 6405 if ( getRuleLevel()==0 ) {dbg.terminate();} 6406 } 6407 6408 return ; 6409 } 6410 // $ANTLR end "elementValue" 6411 6412 6413 // $ANTLR start "elementValueArrayInitializer" 6414 // src/com/google/doclava/parser/Java.g:745:1: elementValueArrayInitializer : '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ; elementValueArrayInitializer()6415 public final void elementValueArrayInitializer() throws RecognitionException { 6416 int elementValueArrayInitializer_StartIndex = input.index(); 6417 try { dbg.enterRule(getGrammarFileName(), "elementValueArrayInitializer"); 6418 if ( getRuleLevel()==0 ) {dbg.commence();} 6419 incRuleLevel(); 6420 dbg.location(745, 1); 6421 6422 try { 6423 if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; } 6424 // src/com/google/doclava/parser/Java.g:746:5: ( '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ) 6425 dbg.enterAlt(1); 6426 6427 // src/com/google/doclava/parser/Java.g:746:9: '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' 6428 { 6429 dbg.location(746,9); 6430 match(input,LBRACE,FOLLOW_LBRACE_in_elementValueArrayInitializer3593); if (state.failed) return ; 6431 dbg.location(747,9); 6432 // src/com/google/doclava/parser/Java.g:747:9: ( elementValue ( ',' elementValue )* )? 6433 int alt84=2; 6434 try { dbg.enterSubRule(84); 6435 try { dbg.enterDecision(84, decisionCanBacktrack[84]); 6436 6437 int LA84_0 = input.LA(1); 6438 6439 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) ) { 6440 alt84=1; 6441 } 6442 } finally {dbg.exitDecision(84);} 6443 6444 switch (alt84) { 6445 case 1 : 6446 dbg.enterAlt(1); 6447 6448 // src/com/google/doclava/parser/Java.g:747:10: elementValue ( ',' elementValue )* 6449 { 6450 dbg.location(747,10); 6451 pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3604); 6452 elementValue(); 6453 6454 state._fsp--; 6455 if (state.failed) return ; 6456 dbg.location(748,13); 6457 // src/com/google/doclava/parser/Java.g:748:13: ( ',' elementValue )* 6458 try { dbg.enterSubRule(83); 6459 6460 loop83: 6461 do { 6462 int alt83=2; 6463 try { dbg.enterDecision(83, decisionCanBacktrack[83]); 6464 6465 int LA83_0 = input.LA(1); 6466 6467 if ( (LA83_0==COMMA) ) { 6468 int LA83_1 = input.LA(2); 6469 6470 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) ) { 6471 alt83=1; 6472 } 6473 6474 6475 } 6476 6477 6478 } finally {dbg.exitDecision(83);} 6479 6480 switch (alt83) { 6481 case 1 : 6482 dbg.enterAlt(1); 6483 6484 // src/com/google/doclava/parser/Java.g:748:14: ',' elementValue 6485 { 6486 dbg.location(748,14); 6487 match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3619); if (state.failed) return ; 6488 dbg.location(748,18); 6489 pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3621); 6490 elementValue(); 6491 6492 state._fsp--; 6493 if (state.failed) return ; 6494 6495 } 6496 break; 6497 6498 default : 6499 break loop83; 6500 } 6501 } while (true); 6502 } finally {dbg.exitSubRule(83);} 6503 6504 6505 } 6506 break; 6507 6508 } 6509 } finally {dbg.exitSubRule(84);} 6510 6511 dbg.location(750,12); 6512 // src/com/google/doclava/parser/Java.g:750:12: ( ',' )? 6513 int alt85=2; 6514 try { dbg.enterSubRule(85); 6515 try { dbg.enterDecision(85, decisionCanBacktrack[85]); 6516 6517 int LA85_0 = input.LA(1); 6518 6519 if ( (LA85_0==COMMA) ) { 6520 alt85=1; 6521 } 6522 } finally {dbg.exitDecision(85);} 6523 6524 switch (alt85) { 6525 case 1 : 6526 dbg.enterAlt(1); 6527 6528 // src/com/google/doclava/parser/Java.g:750:13: ',' 6529 { 6530 dbg.location(750,13); 6531 match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3650); if (state.failed) return ; 6532 6533 } 6534 break; 6535 6536 } 6537 } finally {dbg.exitSubRule(85);} 6538 6539 dbg.location(750,19); 6540 match(input,RBRACE,FOLLOW_RBRACE_in_elementValueArrayInitializer3654); if (state.failed) return ; 6541 6542 } 6543 6544 } 6545 catch (RecognitionException re) { 6546 reportError(re); 6547 recover(input,re); 6548 } 6549 finally { 6550 if ( state.backtracking>0 ) { memoize(input, 49, elementValueArrayInitializer_StartIndex); } 6551 } 6552 dbg.location(751, 5); 6553 6554 } 6555 finally { 6556 dbg.exitRule(getGrammarFileName(), "elementValueArrayInitializer"); 6557 decRuleLevel(); 6558 if ( getRuleLevel()==0 ) {dbg.terminate();} 6559 } 6560 6561 return ; 6562 } 6563 // $ANTLR end "elementValueArrayInitializer" 6564 6565 6566 // $ANTLR start "annotationTypeDeclaration" 6567 // src/com/google/doclava/parser/Java.g:754:1: annotationTypeDeclaration : modifiers '@' 'interface' IDENTIFIER annotationTypeBody ; annotationTypeDeclaration()6568 public final void annotationTypeDeclaration() throws RecognitionException { 6569 int annotationTypeDeclaration_StartIndex = input.index(); 6570 try { dbg.enterRule(getGrammarFileName(), "annotationTypeDeclaration"); 6571 if ( getRuleLevel()==0 ) {dbg.commence();} 6572 incRuleLevel(); 6573 dbg.location(754, 1); 6574 6575 try { 6576 if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; } 6577 // src/com/google/doclava/parser/Java.g:758:5: ( modifiers '@' 'interface' IDENTIFIER annotationTypeBody ) 6578 dbg.enterAlt(1); 6579 6580 // src/com/google/doclava/parser/Java.g:758:9: modifiers '@' 'interface' IDENTIFIER annotationTypeBody 6581 { 6582 dbg.location(758,9); 6583 pushFollow(FOLLOW_modifiers_in_annotationTypeDeclaration3676); 6584 modifiers(); 6585 6586 state._fsp--; 6587 if (state.failed) return ; 6588 dbg.location(758,19); 6589 match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678); if (state.failed) return ; 6590 dbg.location(759,9); 6591 match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationTypeDeclaration3688); if (state.failed) return ; 6592 dbg.location(760,9); 6593 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698); if (state.failed) return ; 6594 dbg.location(761,9); 6595 pushFollow(FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708); 6596 annotationTypeBody(); 6597 6598 state._fsp--; 6599 if (state.failed) return ; 6600 6601 } 6602 6603 } 6604 catch (RecognitionException re) { 6605 reportError(re); 6606 recover(input,re); 6607 } 6608 finally { 6609 if ( state.backtracking>0 ) { memoize(input, 50, annotationTypeDeclaration_StartIndex); } 6610 } 6611 dbg.location(762, 5); 6612 6613 } 6614 finally { 6615 dbg.exitRule(getGrammarFileName(), "annotationTypeDeclaration"); 6616 decRuleLevel(); 6617 if ( getRuleLevel()==0 ) {dbg.terminate();} 6618 } 6619 6620 return ; 6621 } 6622 // $ANTLR end "annotationTypeDeclaration" 6623 6624 6625 // $ANTLR start "annotationTypeBody" 6626 // src/com/google/doclava/parser/Java.g:765:1: annotationTypeBody : '{' ( annotationTypeElementDeclaration )* '}' ; annotationTypeBody()6627 public final void annotationTypeBody() throws RecognitionException { 6628 int annotationTypeBody_StartIndex = input.index(); 6629 try { dbg.enterRule(getGrammarFileName(), "annotationTypeBody"); 6630 if ( getRuleLevel()==0 ) {dbg.commence();} 6631 incRuleLevel(); 6632 dbg.location(765, 1); 6633 6634 try { 6635 if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; } 6636 // src/com/google/doclava/parser/Java.g:766:5: ( '{' ( annotationTypeElementDeclaration )* '}' ) 6637 dbg.enterAlt(1); 6638 6639 // src/com/google/doclava/parser/Java.g:766:9: '{' ( annotationTypeElementDeclaration )* '}' 6640 { 6641 dbg.location(766,9); 6642 match(input,LBRACE,FOLLOW_LBRACE_in_annotationTypeBody3728); if (state.failed) return ; 6643 dbg.location(767,9); 6644 // src/com/google/doclava/parser/Java.g:767:9: ( annotationTypeElementDeclaration )* 6645 try { dbg.enterSubRule(86); 6646 6647 loop86: 6648 do { 6649 int alt86=2; 6650 try { dbg.enterDecision(86, decisionCanBacktrack[86]); 6651 6652 int LA86_0 = input.LA(1); 6653 6654 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) ) { 6655 alt86=1; 6656 } 6657 6658 6659 } finally {dbg.exitDecision(86);} 6660 6661 switch (alt86) { 6662 case 1 : 6663 dbg.enterAlt(1); 6664 6665 // src/com/google/doclava/parser/Java.g:767:10: annotationTypeElementDeclaration 6666 { 6667 dbg.location(767,10); 6668 pushFollow(FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739); 6669 annotationTypeElementDeclaration(); 6670 6671 state._fsp--; 6672 if (state.failed) return ; 6673 6674 } 6675 break; 6676 6677 default : 6678 break loop86; 6679 } 6680 } while (true); 6681 } finally {dbg.exitSubRule(86);} 6682 6683 dbg.location(769,9); 6684 match(input,RBRACE,FOLLOW_RBRACE_in_annotationTypeBody3760); if (state.failed) return ; 6685 6686 } 6687 6688 } 6689 catch (RecognitionException re) { 6690 reportError(re); 6691 recover(input,re); 6692 } 6693 finally { 6694 if ( state.backtracking>0 ) { memoize(input, 51, annotationTypeBody_StartIndex); } 6695 } 6696 dbg.location(770, 5); 6697 6698 } 6699 finally { 6700 dbg.exitRule(getGrammarFileName(), "annotationTypeBody"); 6701 decRuleLevel(); 6702 if ( getRuleLevel()==0 ) {dbg.terminate();} 6703 } 6704 6705 return ; 6706 } 6707 // $ANTLR end "annotationTypeBody" 6708 6709 6710 // $ANTLR start "annotationTypeElementDeclaration" 6711 // src/com/google/doclava/parser/Java.g:772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' ); annotationTypeElementDeclaration()6712 public final void annotationTypeElementDeclaration() throws RecognitionException { 6713 int annotationTypeElementDeclaration_StartIndex = input.index(); 6714 try { dbg.enterRule(getGrammarFileName(), "annotationTypeElementDeclaration"); 6715 if ( getRuleLevel()==0 ) {dbg.commence();} 6716 incRuleLevel(); 6717 dbg.location(772, 1); 6718 6719 try { 6720 if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; } 6721 // src/com/google/doclava/parser/Java.g:776:5: ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' ) 6722 int alt87=7; 6723 try { dbg.enterDecision(87, decisionCanBacktrack[87]); 6724 6725 try { 6726 isCyclicDecision = true; 6727 alt87 = dfa87.predict(input); 6728 } 6729 catch (NoViableAltException nvae) { 6730 dbg.recognitionException(nvae); 6731 throw nvae; 6732 } 6733 } finally {dbg.exitDecision(87);} 6734 6735 switch (alt87) { 6736 case 1 : 6737 dbg.enterAlt(1); 6738 6739 // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration 6740 { 6741 dbg.location(776,9); 6742 pushFollow(FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781); 6743 annotationMethodDeclaration(); 6744 6745 state._fsp--; 6746 if (state.failed) return ; 6747 6748 } 6749 break; 6750 case 2 : 6751 dbg.enterAlt(2); 6752 6753 // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration 6754 { 6755 dbg.location(777,9); 6756 pushFollow(FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791); 6757 interfaceFieldDeclaration(); 6758 6759 state._fsp--; 6760 if (state.failed) return ; 6761 6762 } 6763 break; 6764 case 3 : 6765 dbg.enterAlt(3); 6766 6767 // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration 6768 { 6769 dbg.location(778,9); 6770 pushFollow(FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801); 6771 normalClassDeclaration(); 6772 6773 state._fsp--; 6774 if (state.failed) return ; 6775 6776 } 6777 break; 6778 case 4 : 6779 dbg.enterAlt(4); 6780 6781 // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration 6782 { 6783 dbg.location(779,9); 6784 pushFollow(FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811); 6785 normalInterfaceDeclaration(); 6786 6787 state._fsp--; 6788 if (state.failed) return ; 6789 6790 } 6791 break; 6792 case 5 : 6793 dbg.enterAlt(5); 6794 6795 // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration 6796 { 6797 dbg.location(780,9); 6798 pushFollow(FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821); 6799 enumDeclaration(); 6800 6801 state._fsp--; 6802 if (state.failed) return ; 6803 6804 } 6805 break; 6806 case 6 : 6807 dbg.enterAlt(6); 6808 6809 // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration 6810 { 6811 dbg.location(781,9); 6812 pushFollow(FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831); 6813 annotationTypeDeclaration(); 6814 6815 state._fsp--; 6816 if (state.failed) return ; 6817 6818 } 6819 break; 6820 case 7 : 6821 dbg.enterAlt(7); 6822 6823 // src/com/google/doclava/parser/Java.g:782:9: ';' 6824 { 6825 dbg.location(782,9); 6826 match(input,SEMI,FOLLOW_SEMI_in_annotationTypeElementDeclaration3841); if (state.failed) return ; 6827 6828 } 6829 break; 6830 6831 } 6832 } 6833 catch (RecognitionException re) { 6834 reportError(re); 6835 recover(input,re); 6836 } 6837 finally { 6838 if ( state.backtracking>0 ) { memoize(input, 52, annotationTypeElementDeclaration_StartIndex); } 6839 } 6840 dbg.location(783, 5); 6841 6842 } 6843 finally { 6844 dbg.exitRule(getGrammarFileName(), "annotationTypeElementDeclaration"); 6845 decRuleLevel(); 6846 if ( getRuleLevel()==0 ) {dbg.terminate();} 6847 } 6848 6849 return ; 6850 } 6851 // $ANTLR end "annotationTypeElementDeclaration" 6852 6853 6854 // $ANTLR start "annotationMethodDeclaration" 6855 // src/com/google/doclava/parser/Java.g:785:1: annotationMethodDeclaration : modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' ; annotationMethodDeclaration()6856 public final void annotationMethodDeclaration() throws RecognitionException { 6857 int annotationMethodDeclaration_StartIndex = input.index(); 6858 try { dbg.enterRule(getGrammarFileName(), "annotationMethodDeclaration"); 6859 if ( getRuleLevel()==0 ) {dbg.commence();} 6860 incRuleLevel(); 6861 dbg.location(785, 1); 6862 6863 try { 6864 if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; } 6865 // src/com/google/doclava/parser/Java.g:786:5: ( modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' ) 6866 dbg.enterAlt(1); 6867 6868 // src/com/google/doclava/parser/Java.g:786:9: modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' 6869 { 6870 dbg.location(786,9); 6871 pushFollow(FOLLOW_modifiers_in_annotationMethodDeclaration3860); 6872 modifiers(); 6873 6874 state._fsp--; 6875 if (state.failed) return ; 6876 dbg.location(786,19); 6877 pushFollow(FOLLOW_type_in_annotationMethodDeclaration3862); 6878 type(); 6879 6880 state._fsp--; 6881 if (state.failed) return ; 6882 dbg.location(786,24); 6883 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864); if (state.failed) return ; 6884 dbg.location(787,9); 6885 match(input,LPAREN,FOLLOW_LPAREN_in_annotationMethodDeclaration3874); if (state.failed) return ; 6886 dbg.location(787,13); 6887 match(input,RPAREN,FOLLOW_RPAREN_in_annotationMethodDeclaration3876); if (state.failed) return ; 6888 dbg.location(787,17); 6889 // src/com/google/doclava/parser/Java.g:787:17: ( 'default' elementValue )? 6890 int alt88=2; 6891 try { dbg.enterSubRule(88); 6892 try { dbg.enterDecision(88, decisionCanBacktrack[88]); 6893 6894 int LA88_0 = input.LA(1); 6895 6896 if ( (LA88_0==DEFAULT) ) { 6897 alt88=1; 6898 } 6899 } finally {dbg.exitDecision(88);} 6900 6901 switch (alt88) { 6902 case 1 : 6903 dbg.enterAlt(1); 6904 6905 // src/com/google/doclava/parser/Java.g:787:18: 'default' elementValue 6906 { 6907 dbg.location(787,18); 6908 match(input,DEFAULT,FOLLOW_DEFAULT_in_annotationMethodDeclaration3879); if (state.failed) return ; 6909 dbg.location(787,28); 6910 pushFollow(FOLLOW_elementValue_in_annotationMethodDeclaration3881); 6911 elementValue(); 6912 6913 state._fsp--; 6914 if (state.failed) return ; 6915 6916 } 6917 break; 6918 6919 } 6920 } finally {dbg.exitSubRule(88);} 6921 6922 dbg.location(789,9); 6923 match(input,SEMI,FOLLOW_SEMI_in_annotationMethodDeclaration3910); if (state.failed) return ; 6924 6925 } 6926 6927 } 6928 catch (RecognitionException re) { 6929 reportError(re); 6930 recover(input,re); 6931 } 6932 finally { 6933 if ( state.backtracking>0 ) { memoize(input, 53, annotationMethodDeclaration_StartIndex); } 6934 } 6935 dbg.location(790, 9); 6936 6937 } 6938 finally { 6939 dbg.exitRule(getGrammarFileName(), "annotationMethodDeclaration"); 6940 decRuleLevel(); 6941 if ( getRuleLevel()==0 ) {dbg.terminate();} 6942 } 6943 6944 return ; 6945 } 6946 // $ANTLR end "annotationMethodDeclaration" 6947 6948 6949 // $ANTLR start "block" 6950 // src/com/google/doclava/parser/Java.g:792:1: block : '{' ( blockStatement )* '}' ; block()6951 public final void block() throws RecognitionException { 6952 int block_StartIndex = input.index(); 6953 try { dbg.enterRule(getGrammarFileName(), "block"); 6954 if ( getRuleLevel()==0 ) {dbg.commence();} 6955 incRuleLevel(); 6956 dbg.location(792, 1); 6957 6958 try { 6959 if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; } 6960 // src/com/google/doclava/parser/Java.g:793:5: ( '{' ( blockStatement )* '}' ) 6961 dbg.enterAlt(1); 6962 6963 // src/com/google/doclava/parser/Java.g:793:9: '{' ( blockStatement )* '}' 6964 { 6965 dbg.location(793,9); 6966 match(input,LBRACE,FOLLOW_LBRACE_in_block3933); if (state.failed) return ; 6967 dbg.location(794,9); 6968 // src/com/google/doclava/parser/Java.g:794:9: ( blockStatement )* 6969 try { dbg.enterSubRule(89); 6970 6971 loop89: 6972 do { 6973 int alt89=2; 6974 try { dbg.enterDecision(89, decisionCanBacktrack[89]); 6975 6976 int LA89_0 = input.LA(1); 6977 6978 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) ) { 6979 alt89=1; 6980 } 6981 6982 6983 } finally {dbg.exitDecision(89);} 6984 6985 switch (alt89) { 6986 case 1 : 6987 dbg.enterAlt(1); 6988 6989 // src/com/google/doclava/parser/Java.g:794:10: blockStatement 6990 { 6991 dbg.location(794,10); 6992 pushFollow(FOLLOW_blockStatement_in_block3944); 6993 blockStatement(); 6994 6995 state._fsp--; 6996 if (state.failed) return ; 6997 6998 } 6999 break; 7000 7001 default : 7002 break loop89; 7003 } 7004 } while (true); 7005 } finally {dbg.exitSubRule(89);} 7006 7007 dbg.location(796,9); 7008 match(input,RBRACE,FOLLOW_RBRACE_in_block3965); if (state.failed) return ; 7009 7010 } 7011 7012 } 7013 catch (RecognitionException re) { 7014 reportError(re); 7015 recover(input,re); 7016 } 7017 finally { 7018 if ( state.backtracking>0 ) { memoize(input, 54, block_StartIndex); } 7019 } 7020 dbg.location(797, 5); 7021 7022 } 7023 finally { 7024 dbg.exitRule(getGrammarFileName(), "block"); 7025 decRuleLevel(); 7026 if ( getRuleLevel()==0 ) {dbg.terminate();} 7027 } 7028 7029 return ; 7030 } 7031 // $ANTLR end "block" 7032 7033 7034 // $ANTLR start "blockStatement" 7035 // src/com/google/doclava/parser/Java.g:823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement ); blockStatement()7036 public final void blockStatement() throws RecognitionException { 7037 int blockStatement_StartIndex = input.index(); 7038 try { dbg.enterRule(getGrammarFileName(), "blockStatement"); 7039 if ( getRuleLevel()==0 ) {dbg.commence();} 7040 incRuleLevel(); 7041 dbg.location(823, 1); 7042 7043 try { 7044 if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return ; } 7045 // src/com/google/doclava/parser/Java.g:824:5: ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement ) 7046 int alt90=3; 7047 try { dbg.enterDecision(90, decisionCanBacktrack[90]); 7048 7049 try { 7050 isCyclicDecision = true; 7051 alt90 = dfa90.predict(input); 7052 } 7053 catch (NoViableAltException nvae) { 7054 dbg.recognitionException(nvae); 7055 throw nvae; 7056 } 7057 } finally {dbg.exitDecision(90);} 7058 7059 switch (alt90) { 7060 case 1 : 7061 dbg.enterAlt(1); 7062 7063 // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement 7064 { 7065 dbg.location(824,9); 7066 pushFollow(FOLLOW_localVariableDeclarationStatement_in_blockStatement3986); 7067 localVariableDeclarationStatement(); 7068 7069 state._fsp--; 7070 if (state.failed) return ; 7071 7072 } 7073 break; 7074 case 2 : 7075 dbg.enterAlt(2); 7076 7077 // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration 7078 { 7079 dbg.location(825,9); 7080 pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996); 7081 classOrInterfaceDeclaration(); 7082 7083 state._fsp--; 7084 if (state.failed) return ; 7085 7086 } 7087 break; 7088 case 3 : 7089 dbg.enterAlt(3); 7090 7091 // src/com/google/doclava/parser/Java.g:826:9: statement 7092 { 7093 dbg.location(826,9); 7094 pushFollow(FOLLOW_statement_in_blockStatement4006); 7095 statement(); 7096 7097 state._fsp--; 7098 if (state.failed) return ; 7099 7100 } 7101 break; 7102 7103 } 7104 } 7105 catch (RecognitionException re) { 7106 reportError(re); 7107 recover(input,re); 7108 } 7109 finally { 7110 if ( state.backtracking>0 ) { memoize(input, 55, blockStatement_StartIndex); } 7111 } 7112 dbg.location(827, 5); 7113 7114 } 7115 finally { 7116 dbg.exitRule(getGrammarFileName(), "blockStatement"); 7117 decRuleLevel(); 7118 if ( getRuleLevel()==0 ) {dbg.terminate();} 7119 } 7120 7121 return ; 7122 } 7123 // $ANTLR end "blockStatement" 7124 7125 7126 // $ANTLR start "localVariableDeclarationStatement" 7127 // src/com/google/doclava/parser/Java.g:830:1: localVariableDeclarationStatement : localVariableDeclaration ';' ; localVariableDeclarationStatement()7128 public final void localVariableDeclarationStatement() throws RecognitionException { 7129 int localVariableDeclarationStatement_StartIndex = input.index(); 7130 try { dbg.enterRule(getGrammarFileName(), "localVariableDeclarationStatement"); 7131 if ( getRuleLevel()==0 ) {dbg.commence();} 7132 incRuleLevel(); 7133 dbg.location(830, 1); 7134 7135 try { 7136 if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; } 7137 // src/com/google/doclava/parser/Java.g:831:5: ( localVariableDeclaration ';' ) 7138 dbg.enterAlt(1); 7139 7140 // src/com/google/doclava/parser/Java.g:831:9: localVariableDeclaration ';' 7141 { 7142 dbg.location(831,9); 7143 pushFollow(FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026); 7144 localVariableDeclaration(); 7145 7146 state._fsp--; 7147 if (state.failed) return ; 7148 dbg.location(832,9); 7149 match(input,SEMI,FOLLOW_SEMI_in_localVariableDeclarationStatement4036); if (state.failed) return ; 7150 7151 } 7152 7153 } 7154 catch (RecognitionException re) { 7155 reportError(re); 7156 recover(input,re); 7157 } 7158 finally { 7159 if ( state.backtracking>0 ) { memoize(input, 56, localVariableDeclarationStatement_StartIndex); } 7160 } 7161 dbg.location(833, 5); 7162 7163 } 7164 finally { 7165 dbg.exitRule(getGrammarFileName(), "localVariableDeclarationStatement"); 7166 decRuleLevel(); 7167 if ( getRuleLevel()==0 ) {dbg.terminate();} 7168 } 7169 7170 return ; 7171 } 7172 // $ANTLR end "localVariableDeclarationStatement" 7173 7174 7175 // $ANTLR start "localVariableDeclaration" 7176 // src/com/google/doclava/parser/Java.g:835:1: localVariableDeclaration : variableModifiers type variableDeclarator ( ',' variableDeclarator )* ; localVariableDeclaration()7177 public final void localVariableDeclaration() throws RecognitionException { 7178 int localVariableDeclaration_StartIndex = input.index(); 7179 try { dbg.enterRule(getGrammarFileName(), "localVariableDeclaration"); 7180 if ( getRuleLevel()==0 ) {dbg.commence();} 7181 incRuleLevel(); 7182 dbg.location(835, 1); 7183 7184 try { 7185 if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; } 7186 // src/com/google/doclava/parser/Java.g:836:5: ( variableModifiers type variableDeclarator ( ',' variableDeclarator )* ) 7187 dbg.enterAlt(1); 7188 7189 // src/com/google/doclava/parser/Java.g:836:9: variableModifiers type variableDeclarator ( ',' variableDeclarator )* 7190 { 7191 dbg.location(836,9); 7192 pushFollow(FOLLOW_variableModifiers_in_localVariableDeclaration4055); 7193 variableModifiers(); 7194 7195 state._fsp--; 7196 if (state.failed) return ; 7197 dbg.location(836,27); 7198 pushFollow(FOLLOW_type_in_localVariableDeclaration4057); 7199 type(); 7200 7201 state._fsp--; 7202 if (state.failed) return ; 7203 dbg.location(837,9); 7204 pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4067); 7205 variableDeclarator(); 7206 7207 state._fsp--; 7208 if (state.failed) return ; 7209 dbg.location(838,9); 7210 // src/com/google/doclava/parser/Java.g:838:9: ( ',' variableDeclarator )* 7211 try { dbg.enterSubRule(91); 7212 7213 loop91: 7214 do { 7215 int alt91=2; 7216 try { dbg.enterDecision(91, decisionCanBacktrack[91]); 7217 7218 int LA91_0 = input.LA(1); 7219 7220 if ( (LA91_0==COMMA) ) { 7221 alt91=1; 7222 } 7223 7224 7225 } finally {dbg.exitDecision(91);} 7226 7227 switch (alt91) { 7228 case 1 : 7229 dbg.enterAlt(1); 7230 7231 // src/com/google/doclava/parser/Java.g:838:10: ',' variableDeclarator 7232 { 7233 dbg.location(838,10); 7234 match(input,COMMA,FOLLOW_COMMA_in_localVariableDeclaration4078); if (state.failed) return ; 7235 dbg.location(838,14); 7236 pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4080); 7237 variableDeclarator(); 7238 7239 state._fsp--; 7240 if (state.failed) return ; 7241 7242 } 7243 break; 7244 7245 default : 7246 break loop91; 7247 } 7248 } while (true); 7249 } finally {dbg.exitSubRule(91);} 7250 7251 7252 } 7253 7254 } 7255 catch (RecognitionException re) { 7256 reportError(re); 7257 recover(input,re); 7258 } 7259 finally { 7260 if ( state.backtracking>0 ) { memoize(input, 57, localVariableDeclaration_StartIndex); } 7261 } 7262 dbg.location(840, 5); 7263 7264 } 7265 finally { 7266 dbg.exitRule(getGrammarFileName(), "localVariableDeclaration"); 7267 decRuleLevel(); 7268 if ( getRuleLevel()==0 ) {dbg.terminate();} 7269 } 7270 7271 return ; 7272 } 7273 // $ANTLR end "localVariableDeclaration" 7274 7275 7276 // $ANTLR start "statement" 7277 // 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 | ';' ); statement()7278 public final void statement() throws RecognitionException { 7279 int statement_StartIndex = input.index(); 7280 try { dbg.enterRule(getGrammarFileName(), "statement"); 7281 if ( getRuleLevel()==0 ) {dbg.commence();} 7282 incRuleLevel(); 7283 dbg.location(842, 1); 7284 7285 try { 7286 if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; } 7287 // 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 | ';' ) 7288 int alt98=17; 7289 try { dbg.enterDecision(98, decisionCanBacktrack[98]); 7290 7291 try { 7292 isCyclicDecision = true; 7293 alt98 = dfa98.predict(input); 7294 } 7295 catch (NoViableAltException nvae) { 7296 dbg.recognitionException(nvae); 7297 throw nvae; 7298 } 7299 } finally {dbg.exitDecision(98);} 7300 7301 switch (alt98) { 7302 case 1 : 7303 dbg.enterAlt(1); 7304 7305 // src/com/google/doclava/parser/Java.g:843:9: block 7306 { 7307 dbg.location(843,9); 7308 pushFollow(FOLLOW_block_in_statement4110); 7309 block(); 7310 7311 state._fsp--; 7312 if (state.failed) return ; 7313 7314 } 7315 break; 7316 case 2 : 7317 dbg.enterAlt(2); 7318 7319 // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';' 7320 { 7321 dbg.location(845,9); 7322 // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) 7323 dbg.enterAlt(1); 7324 7325 // src/com/google/doclava/parser/Java.g:845:10: 'assert' 7326 { 7327 dbg.location(845,10); 7328 match(input,ASSERT,FOLLOW_ASSERT_in_statement4122); if (state.failed) return ; 7329 7330 } 7331 7332 dbg.location(847,9); 7333 pushFollow(FOLLOW_expression_in_statement4142); 7334 expression(); 7335 7336 state._fsp--; 7337 if (state.failed) return ; 7338 dbg.location(847,20); 7339 // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )? 7340 int alt92=2; 7341 try { dbg.enterSubRule(92); 7342 try { dbg.enterDecision(92, decisionCanBacktrack[92]); 7343 7344 int LA92_0 = input.LA(1); 7345 7346 if ( (LA92_0==COLON) ) { 7347 alt92=1; 7348 } 7349 } finally {dbg.exitDecision(92);} 7350 7351 switch (alt92) { 7352 case 1 : 7353 dbg.enterAlt(1); 7354 7355 // src/com/google/doclava/parser/Java.g:847:21: ':' expression 7356 { 7357 dbg.location(847,21); 7358 match(input,COLON,FOLLOW_COLON_in_statement4145); if (state.failed) return ; 7359 dbg.location(847,25); 7360 pushFollow(FOLLOW_expression_in_statement4147); 7361 expression(); 7362 7363 state._fsp--; 7364 if (state.failed) return ; 7365 7366 } 7367 break; 7368 7369 } 7370 } finally {dbg.exitSubRule(92);} 7371 7372 dbg.location(847,38); 7373 match(input,SEMI,FOLLOW_SEMI_in_statement4151); if (state.failed) return ; 7374 7375 } 7376 break; 7377 case 3 : 7378 dbg.enterAlt(3); 7379 7380 // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';' 7381 { 7382 dbg.location(848,9); 7383 match(input,ASSERT,FOLLOW_ASSERT_in_statement4161); if (state.failed) return ; 7384 dbg.location(848,19); 7385 pushFollow(FOLLOW_expression_in_statement4164); 7386 expression(); 7387 7388 state._fsp--; 7389 if (state.failed) return ; 7390 dbg.location(848,30); 7391 // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )? 7392 int alt93=2; 7393 try { dbg.enterSubRule(93); 7394 try { dbg.enterDecision(93, decisionCanBacktrack[93]); 7395 7396 int LA93_0 = input.LA(1); 7397 7398 if ( (LA93_0==COLON) ) { 7399 alt93=1; 7400 } 7401 } finally {dbg.exitDecision(93);} 7402 7403 switch (alt93) { 7404 case 1 : 7405 dbg.enterAlt(1); 7406 7407 // src/com/google/doclava/parser/Java.g:848:31: ':' expression 7408 { 7409 dbg.location(848,31); 7410 match(input,COLON,FOLLOW_COLON_in_statement4167); if (state.failed) return ; 7411 dbg.location(848,35); 7412 pushFollow(FOLLOW_expression_in_statement4169); 7413 expression(); 7414 7415 state._fsp--; 7416 if (state.failed) return ; 7417 7418 } 7419 break; 7420 7421 } 7422 } finally {dbg.exitSubRule(93);} 7423 7424 dbg.location(848,48); 7425 match(input,SEMI,FOLLOW_SEMI_in_statement4173); if (state.failed) return ; 7426 7427 } 7428 break; 7429 case 4 : 7430 dbg.enterAlt(4); 7431 7432 // src/com/google/doclava/parser/Java.g:849:9: 'if' parExpression statement ( 'else' statement )? 7433 { 7434 dbg.location(849,9); 7435 match(input,IF,FOLLOW_IF_in_statement4183); if (state.failed) return ; 7436 dbg.location(849,14); 7437 pushFollow(FOLLOW_parExpression_in_statement4185); 7438 parExpression(); 7439 7440 state._fsp--; 7441 if (state.failed) return ; 7442 dbg.location(849,28); 7443 pushFollow(FOLLOW_statement_in_statement4187); 7444 statement(); 7445 7446 state._fsp--; 7447 if (state.failed) return ; 7448 dbg.location(849,38); 7449 // src/com/google/doclava/parser/Java.g:849:38: ( 'else' statement )? 7450 int alt94=2; 7451 try { dbg.enterSubRule(94); 7452 try { dbg.enterDecision(94, decisionCanBacktrack[94]); 7453 7454 int LA94_0 = input.LA(1); 7455 7456 if ( (LA94_0==ELSE) ) { 7457 int LA94_1 = input.LA(2); 7458 7459 if ( (synpred133_Java()) ) { 7460 alt94=1; 7461 } 7462 } 7463 } finally {dbg.exitDecision(94);} 7464 7465 switch (alt94) { 7466 case 1 : 7467 dbg.enterAlt(1); 7468 7469 // src/com/google/doclava/parser/Java.g:849:39: 'else' statement 7470 { 7471 dbg.location(849,39); 7472 match(input,ELSE,FOLLOW_ELSE_in_statement4190); if (state.failed) return ; 7473 dbg.location(849,46); 7474 pushFollow(FOLLOW_statement_in_statement4192); 7475 statement(); 7476 7477 state._fsp--; 7478 if (state.failed) return ; 7479 7480 } 7481 break; 7482 7483 } 7484 } finally {dbg.exitSubRule(94);} 7485 7486 7487 } 7488 break; 7489 case 5 : 7490 dbg.enterAlt(5); 7491 7492 // src/com/google/doclava/parser/Java.g:850:9: forstatement 7493 { 7494 dbg.location(850,9); 7495 pushFollow(FOLLOW_forstatement_in_statement4204); 7496 forstatement(); 7497 7498 state._fsp--; 7499 if (state.failed) return ; 7500 7501 } 7502 break; 7503 case 6 : 7504 dbg.enterAlt(6); 7505 7506 // src/com/google/doclava/parser/Java.g:851:9: 'while' parExpression statement 7507 { 7508 dbg.location(851,9); 7509 match(input,WHILE,FOLLOW_WHILE_in_statement4214); if (state.failed) return ; 7510 dbg.location(851,17); 7511 pushFollow(FOLLOW_parExpression_in_statement4216); 7512 parExpression(); 7513 7514 state._fsp--; 7515 if (state.failed) return ; 7516 dbg.location(851,31); 7517 pushFollow(FOLLOW_statement_in_statement4218); 7518 statement(); 7519 7520 state._fsp--; 7521 if (state.failed) return ; 7522 7523 } 7524 break; 7525 case 7 : 7526 dbg.enterAlt(7); 7527 7528 // src/com/google/doclava/parser/Java.g:852:9: 'do' statement 'while' parExpression ';' 7529 { 7530 dbg.location(852,9); 7531 match(input,DO,FOLLOW_DO_in_statement4228); if (state.failed) return ; 7532 dbg.location(852,14); 7533 pushFollow(FOLLOW_statement_in_statement4230); 7534 statement(); 7535 7536 state._fsp--; 7537 if (state.failed) return ; 7538 dbg.location(852,24); 7539 match(input,WHILE,FOLLOW_WHILE_in_statement4232); if (state.failed) return ; 7540 dbg.location(852,32); 7541 pushFollow(FOLLOW_parExpression_in_statement4234); 7542 parExpression(); 7543 7544 state._fsp--; 7545 if (state.failed) return ; 7546 dbg.location(852,46); 7547 match(input,SEMI,FOLLOW_SEMI_in_statement4236); if (state.failed) return ; 7548 7549 } 7550 break; 7551 case 8 : 7552 dbg.enterAlt(8); 7553 7554 // src/com/google/doclava/parser/Java.g:853:9: trystatement 7555 { 7556 dbg.location(853,9); 7557 pushFollow(FOLLOW_trystatement_in_statement4246); 7558 trystatement(); 7559 7560 state._fsp--; 7561 if (state.failed) return ; 7562 7563 } 7564 break; 7565 case 9 : 7566 dbg.enterAlt(9); 7567 7568 // src/com/google/doclava/parser/Java.g:854:9: 'switch' parExpression '{' switchBlockStatementGroups '}' 7569 { 7570 dbg.location(854,9); 7571 match(input,SWITCH,FOLLOW_SWITCH_in_statement4256); if (state.failed) return ; 7572 dbg.location(854,18); 7573 pushFollow(FOLLOW_parExpression_in_statement4258); 7574 parExpression(); 7575 7576 state._fsp--; 7577 if (state.failed) return ; 7578 dbg.location(854,32); 7579 match(input,LBRACE,FOLLOW_LBRACE_in_statement4260); if (state.failed) return ; 7580 dbg.location(854,36); 7581 pushFollow(FOLLOW_switchBlockStatementGroups_in_statement4262); 7582 switchBlockStatementGroups(); 7583 7584 state._fsp--; 7585 if (state.failed) return ; 7586 dbg.location(854,63); 7587 match(input,RBRACE,FOLLOW_RBRACE_in_statement4264); if (state.failed) return ; 7588 7589 } 7590 break; 7591 case 10 : 7592 dbg.enterAlt(10); 7593 7594 // src/com/google/doclava/parser/Java.g:855:9: 'synchronized' parExpression block 7595 { 7596 dbg.location(855,9); 7597 match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_statement4274); if (state.failed) return ; 7598 dbg.location(855,24); 7599 pushFollow(FOLLOW_parExpression_in_statement4276); 7600 parExpression(); 7601 7602 state._fsp--; 7603 if (state.failed) return ; 7604 dbg.location(855,38); 7605 pushFollow(FOLLOW_block_in_statement4278); 7606 block(); 7607 7608 state._fsp--; 7609 if (state.failed) return ; 7610 7611 } 7612 break; 7613 case 11 : 7614 dbg.enterAlt(11); 7615 7616 // src/com/google/doclava/parser/Java.g:856:9: 'return' ( expression )? ';' 7617 { 7618 dbg.location(856,9); 7619 match(input,RETURN,FOLLOW_RETURN_in_statement4288); if (state.failed) return ; 7620 dbg.location(856,18); 7621 // src/com/google/doclava/parser/Java.g:856:18: ( expression )? 7622 int alt95=2; 7623 try { dbg.enterSubRule(95); 7624 try { dbg.enterDecision(95, decisionCanBacktrack[95]); 7625 7626 int LA95_0 = input.LA(1); 7627 7628 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)) ) { 7629 alt95=1; 7630 } 7631 } finally {dbg.exitDecision(95);} 7632 7633 switch (alt95) { 7634 case 1 : 7635 dbg.enterAlt(1); 7636 7637 // src/com/google/doclava/parser/Java.g:856:19: expression 7638 { 7639 dbg.location(856,19); 7640 pushFollow(FOLLOW_expression_in_statement4291); 7641 expression(); 7642 7643 state._fsp--; 7644 if (state.failed) return ; 7645 7646 } 7647 break; 7648 7649 } 7650 } finally {dbg.exitSubRule(95);} 7651 7652 dbg.location(856,33); 7653 match(input,SEMI,FOLLOW_SEMI_in_statement4296); if (state.failed) return ; 7654 7655 } 7656 break; 7657 case 12 : 7658 dbg.enterAlt(12); 7659 7660 // src/com/google/doclava/parser/Java.g:857:9: 'throw' expression ';' 7661 { 7662 dbg.location(857,9); 7663 match(input,THROW,FOLLOW_THROW_in_statement4306); if (state.failed) return ; 7664 dbg.location(857,17); 7665 pushFollow(FOLLOW_expression_in_statement4308); 7666 expression(); 7667 7668 state._fsp--; 7669 if (state.failed) return ; 7670 dbg.location(857,28); 7671 match(input,SEMI,FOLLOW_SEMI_in_statement4310); if (state.failed) return ; 7672 7673 } 7674 break; 7675 case 13 : 7676 dbg.enterAlt(13); 7677 7678 // src/com/google/doclava/parser/Java.g:858:9: 'break' ( IDENTIFIER )? ';' 7679 { 7680 dbg.location(858,9); 7681 match(input,BREAK,FOLLOW_BREAK_in_statement4320); if (state.failed) return ; 7682 dbg.location(859,13); 7683 // src/com/google/doclava/parser/Java.g:859:13: ( IDENTIFIER )? 7684 int alt96=2; 7685 try { dbg.enterSubRule(96); 7686 try { dbg.enterDecision(96, decisionCanBacktrack[96]); 7687 7688 int LA96_0 = input.LA(1); 7689 7690 if ( (LA96_0==IDENTIFIER) ) { 7691 alt96=1; 7692 } 7693 } finally {dbg.exitDecision(96);} 7694 7695 switch (alt96) { 7696 case 1 : 7697 dbg.enterAlt(1); 7698 7699 // src/com/google/doclava/parser/Java.g:859:14: IDENTIFIER 7700 { 7701 dbg.location(859,14); 7702 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4335); if (state.failed) return ; 7703 7704 } 7705 break; 7706 7707 } 7708 } finally {dbg.exitSubRule(96);} 7709 7710 dbg.location(860,16); 7711 match(input,SEMI,FOLLOW_SEMI_in_statement4352); if (state.failed) return ; 7712 7713 } 7714 break; 7715 case 14 : 7716 dbg.enterAlt(14); 7717 7718 // src/com/google/doclava/parser/Java.g:861:9: 'continue' ( IDENTIFIER )? ';' 7719 { 7720 dbg.location(861,9); 7721 match(input,CONTINUE,FOLLOW_CONTINUE_in_statement4362); if (state.failed) return ; 7722 dbg.location(862,13); 7723 // src/com/google/doclava/parser/Java.g:862:13: ( IDENTIFIER )? 7724 int alt97=2; 7725 try { dbg.enterSubRule(97); 7726 try { dbg.enterDecision(97, decisionCanBacktrack[97]); 7727 7728 int LA97_0 = input.LA(1); 7729 7730 if ( (LA97_0==IDENTIFIER) ) { 7731 alt97=1; 7732 } 7733 } finally {dbg.exitDecision(97);} 7734 7735 switch (alt97) { 7736 case 1 : 7737 dbg.enterAlt(1); 7738 7739 // src/com/google/doclava/parser/Java.g:862:14: IDENTIFIER 7740 { 7741 dbg.location(862,14); 7742 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4377); if (state.failed) return ; 7743 7744 } 7745 break; 7746 7747 } 7748 } finally {dbg.exitSubRule(97);} 7749 7750 dbg.location(863,16); 7751 match(input,SEMI,FOLLOW_SEMI_in_statement4394); if (state.failed) return ; 7752 7753 } 7754 break; 7755 case 15 : 7756 dbg.enterAlt(15); 7757 7758 // src/com/google/doclava/parser/Java.g:864:9: expression ';' 7759 { 7760 dbg.location(864,9); 7761 pushFollow(FOLLOW_expression_in_statement4404); 7762 expression(); 7763 7764 state._fsp--; 7765 if (state.failed) return ; 7766 dbg.location(864,21); 7767 match(input,SEMI,FOLLOW_SEMI_in_statement4407); if (state.failed) return ; 7768 7769 } 7770 break; 7771 case 16 : 7772 dbg.enterAlt(16); 7773 7774 // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement 7775 { 7776 dbg.location(865,9); 7777 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4417); if (state.failed) return ; 7778 dbg.location(865,20); 7779 match(input,COLON,FOLLOW_COLON_in_statement4419); if (state.failed) return ; 7780 dbg.location(865,24); 7781 pushFollow(FOLLOW_statement_in_statement4421); 7782 statement(); 7783 7784 state._fsp--; 7785 if (state.failed) return ; 7786 7787 } 7788 break; 7789 case 17 : 7790 dbg.enterAlt(17); 7791 7792 // src/com/google/doclava/parser/Java.g:866:9: ';' 7793 { 7794 dbg.location(866,9); 7795 match(input,SEMI,FOLLOW_SEMI_in_statement4431); if (state.failed) return ; 7796 7797 } 7798 break; 7799 7800 } 7801 } 7802 catch (RecognitionException re) { 7803 reportError(re); 7804 recover(input,re); 7805 } 7806 finally { 7807 if ( state.backtracking>0 ) { memoize(input, 58, statement_StartIndex); } 7808 } 7809 dbg.location(868, 5); 7810 7811 } 7812 finally { 7813 dbg.exitRule(getGrammarFileName(), "statement"); 7814 decRuleLevel(); 7815 if ( getRuleLevel()==0 ) {dbg.terminate();} 7816 } 7817 7818 return ; 7819 } 7820 // $ANTLR end "statement" 7821 7822 7823 // $ANTLR start "switchBlockStatementGroups" 7824 // src/com/google/doclava/parser/Java.g:870:1: switchBlockStatementGroups : ( switchBlockStatementGroup )* ; switchBlockStatementGroups()7825 public final void switchBlockStatementGroups() throws RecognitionException { 7826 int switchBlockStatementGroups_StartIndex = input.index(); 7827 try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroups"); 7828 if ( getRuleLevel()==0 ) {dbg.commence();} 7829 incRuleLevel(); 7830 dbg.location(870, 1); 7831 7832 try { 7833 if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; } 7834 // src/com/google/doclava/parser/Java.g:871:5: ( ( switchBlockStatementGroup )* ) 7835 dbg.enterAlt(1); 7836 7837 // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )* 7838 { 7839 dbg.location(871,9); 7840 // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )* 7841 try { dbg.enterSubRule(99); 7842 7843 loop99: 7844 do { 7845 int alt99=2; 7846 try { dbg.enterDecision(99, decisionCanBacktrack[99]); 7847 7848 int LA99_0 = input.LA(1); 7849 7850 if ( (LA99_0==CASE||LA99_0==DEFAULT) ) { 7851 alt99=1; 7852 } 7853 7854 7855 } finally {dbg.exitDecision(99);} 7856 7857 switch (alt99) { 7858 case 1 : 7859 dbg.enterAlt(1); 7860 7861 // src/com/google/doclava/parser/Java.g:871:10: switchBlockStatementGroup 7862 { 7863 dbg.location(871,10); 7864 pushFollow(FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452); 7865 switchBlockStatementGroup(); 7866 7867 state._fsp--; 7868 if (state.failed) return ; 7869 7870 } 7871 break; 7872 7873 default : 7874 break loop99; 7875 } 7876 } while (true); 7877 } finally {dbg.exitSubRule(99);} 7878 7879 7880 } 7881 7882 } 7883 catch (RecognitionException re) { 7884 reportError(re); 7885 recover(input,re); 7886 } 7887 finally { 7888 if ( state.backtracking>0 ) { memoize(input, 59, switchBlockStatementGroups_StartIndex); } 7889 } 7890 dbg.location(872, 5); 7891 7892 } 7893 finally { 7894 dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroups"); 7895 decRuleLevel(); 7896 if ( getRuleLevel()==0 ) {dbg.terminate();} 7897 } 7898 7899 return ; 7900 } 7901 // $ANTLR end "switchBlockStatementGroups" 7902 7903 7904 // $ANTLR start "switchBlockStatementGroup" 7905 // src/com/google/doclava/parser/Java.g:874:1: switchBlockStatementGroup : switchLabel ( blockStatement )* ; switchBlockStatementGroup()7906 public final void switchBlockStatementGroup() throws RecognitionException { 7907 int switchBlockStatementGroup_StartIndex = input.index(); 7908 try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroup"); 7909 if ( getRuleLevel()==0 ) {dbg.commence();} 7910 incRuleLevel(); 7911 dbg.location(874, 1); 7912 7913 try { 7914 if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; } 7915 // src/com/google/doclava/parser/Java.g:875:5: ( switchLabel ( blockStatement )* ) 7916 dbg.enterAlt(1); 7917 7918 // src/com/google/doclava/parser/Java.g:876:9: switchLabel ( blockStatement )* 7919 { 7920 dbg.location(876,9); 7921 pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup4480); 7922 switchLabel(); 7923 7924 state._fsp--; 7925 if (state.failed) return ; 7926 dbg.location(877,9); 7927 // src/com/google/doclava/parser/Java.g:877:9: ( blockStatement )* 7928 try { dbg.enterSubRule(100); 7929 7930 loop100: 7931 do { 7932 int alt100=2; 7933 try { dbg.enterDecision(100, decisionCanBacktrack[100]); 7934 7935 int LA100_0 = input.LA(1); 7936 7937 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) ) { 7938 alt100=1; 7939 } 7940 7941 7942 } finally {dbg.exitDecision(100);} 7943 7944 switch (alt100) { 7945 case 1 : 7946 dbg.enterAlt(1); 7947 7948 // src/com/google/doclava/parser/Java.g:877:10: blockStatement 7949 { 7950 dbg.location(877,10); 7951 pushFollow(FOLLOW_blockStatement_in_switchBlockStatementGroup4491); 7952 blockStatement(); 7953 7954 state._fsp--; 7955 if (state.failed) return ; 7956 7957 } 7958 break; 7959 7960 default : 7961 break loop100; 7962 } 7963 } while (true); 7964 } finally {dbg.exitSubRule(100);} 7965 7966 7967 } 7968 7969 } 7970 catch (RecognitionException re) { 7971 reportError(re); 7972 recover(input,re); 7973 } 7974 finally { 7975 if ( state.backtracking>0 ) { memoize(input, 60, switchBlockStatementGroup_StartIndex); } 7976 } 7977 dbg.location(879, 5); 7978 7979 } 7980 finally { 7981 dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroup"); 7982 decRuleLevel(); 7983 if ( getRuleLevel()==0 ) {dbg.terminate();} 7984 } 7985 7986 return ; 7987 } 7988 // $ANTLR end "switchBlockStatementGroup" 7989 7990 7991 // $ANTLR start "switchLabel" 7992 // src/com/google/doclava/parser/Java.g:881:1: switchLabel : ( 'case' expression ':' | 'default' ':' ); switchLabel()7993 public final void switchLabel() throws RecognitionException { 7994 int switchLabel_StartIndex = input.index(); 7995 try { dbg.enterRule(getGrammarFileName(), "switchLabel"); 7996 if ( getRuleLevel()==0 ) {dbg.commence();} 7997 incRuleLevel(); 7998 dbg.location(881, 1); 7999 8000 try { 8001 if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; } 8002 // src/com/google/doclava/parser/Java.g:882:5: ( 'case' expression ':' | 'default' ':' ) 8003 int alt101=2; 8004 try { dbg.enterDecision(101, decisionCanBacktrack[101]); 8005 8006 int LA101_0 = input.LA(1); 8007 8008 if ( (LA101_0==CASE) ) { 8009 alt101=1; 8010 } 8011 else if ( (LA101_0==DEFAULT) ) { 8012 alt101=2; 8013 } 8014 else { 8015 if (state.backtracking>0) {state.failed=true; return ;} 8016 NoViableAltException nvae = 8017 new NoViableAltException("", 101, 0, input); 8018 8019 dbg.recognitionException(nvae); 8020 throw nvae; 8021 } 8022 } finally {dbg.exitDecision(101);} 8023 8024 switch (alt101) { 8025 case 1 : 8026 dbg.enterAlt(1); 8027 8028 // src/com/google/doclava/parser/Java.g:882:9: 'case' expression ':' 8029 { 8030 dbg.location(882,9); 8031 match(input,CASE,FOLLOW_CASE_in_switchLabel4521); if (state.failed) return ; 8032 dbg.location(882,16); 8033 pushFollow(FOLLOW_expression_in_switchLabel4523); 8034 expression(); 8035 8036 state._fsp--; 8037 if (state.failed) return ; 8038 dbg.location(882,27); 8039 match(input,COLON,FOLLOW_COLON_in_switchLabel4525); if (state.failed) return ; 8040 8041 } 8042 break; 8043 case 2 : 8044 dbg.enterAlt(2); 8045 8046 // src/com/google/doclava/parser/Java.g:883:9: 'default' ':' 8047 { 8048 dbg.location(883,9); 8049 match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel4535); if (state.failed) return ; 8050 dbg.location(883,19); 8051 match(input,COLON,FOLLOW_COLON_in_switchLabel4537); if (state.failed) return ; 8052 8053 } 8054 break; 8055 8056 } 8057 } 8058 catch (RecognitionException re) { 8059 reportError(re); 8060 recover(input,re); 8061 } 8062 finally { 8063 if ( state.backtracking>0 ) { memoize(input, 61, switchLabel_StartIndex); } 8064 } 8065 dbg.location(884, 5); 8066 8067 } 8068 finally { 8069 dbg.exitRule(getGrammarFileName(), "switchLabel"); 8070 decRuleLevel(); 8071 if ( getRuleLevel()==0 ) {dbg.terminate();} 8072 } 8073 8074 return ; 8075 } 8076 // $ANTLR end "switchLabel" 8077 8078 8079 // $ANTLR start "trystatement" 8080 // src/com/google/doclava/parser/Java.g:887:1: trystatement : 'try' block ( catches 'finally' block | catches | 'finally' block ) ; trystatement()8081 public final void trystatement() throws RecognitionException { 8082 int trystatement_StartIndex = input.index(); 8083 try { dbg.enterRule(getGrammarFileName(), "trystatement"); 8084 if ( getRuleLevel()==0 ) {dbg.commence();} 8085 incRuleLevel(); 8086 dbg.location(887, 1); 8087 8088 try { 8089 if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; } 8090 // src/com/google/doclava/parser/Java.g:888:5: ( 'try' block ( catches 'finally' block | catches | 'finally' block ) ) 8091 dbg.enterAlt(1); 8092 8093 // src/com/google/doclava/parser/Java.g:888:9: 'try' block ( catches 'finally' block | catches | 'finally' block ) 8094 { 8095 dbg.location(888,9); 8096 match(input,TRY,FOLLOW_TRY_in_trystatement4557); if (state.failed) return ; 8097 dbg.location(888,15); 8098 pushFollow(FOLLOW_block_in_trystatement4559); 8099 block(); 8100 8101 state._fsp--; 8102 if (state.failed) return ; 8103 dbg.location(889,9); 8104 // src/com/google/doclava/parser/Java.g:889:9: ( catches 'finally' block | catches | 'finally' block ) 8105 int alt102=3; 8106 try { dbg.enterSubRule(102); 8107 try { dbg.enterDecision(102, decisionCanBacktrack[102]); 8108 8109 int LA102_0 = input.LA(1); 8110 8111 if ( (LA102_0==CATCH) ) { 8112 int LA102_1 = input.LA(2); 8113 8114 if ( (synpred153_Java()) ) { 8115 alt102=1; 8116 } 8117 else if ( (synpred154_Java()) ) { 8118 alt102=2; 8119 } 8120 else { 8121 if (state.backtracking>0) {state.failed=true; return ;} 8122 NoViableAltException nvae = 8123 new NoViableAltException("", 102, 1, input); 8124 8125 dbg.recognitionException(nvae); 8126 throw nvae; 8127 } 8128 } 8129 else if ( (LA102_0==FINALLY) ) { 8130 alt102=3; 8131 } 8132 else { 8133 if (state.backtracking>0) {state.failed=true; return ;} 8134 NoViableAltException nvae = 8135 new NoViableAltException("", 102, 0, input); 8136 8137 dbg.recognitionException(nvae); 8138 throw nvae; 8139 } 8140 } finally {dbg.exitDecision(102);} 8141 8142 switch (alt102) { 8143 case 1 : 8144 dbg.enterAlt(1); 8145 8146 // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block 8147 { 8148 dbg.location(889,13); 8149 pushFollow(FOLLOW_catches_in_trystatement4573); 8150 catches(); 8151 8152 state._fsp--; 8153 if (state.failed) return ; 8154 dbg.location(889,21); 8155 match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4575); if (state.failed) return ; 8156 dbg.location(889,31); 8157 pushFollow(FOLLOW_block_in_trystatement4577); 8158 block(); 8159 8160 state._fsp--; 8161 if (state.failed) return ; 8162 8163 } 8164 break; 8165 case 2 : 8166 dbg.enterAlt(2); 8167 8168 // src/com/google/doclava/parser/Java.g:890:13: catches 8169 { 8170 dbg.location(890,13); 8171 pushFollow(FOLLOW_catches_in_trystatement4591); 8172 catches(); 8173 8174 state._fsp--; 8175 if (state.failed) return ; 8176 8177 } 8178 break; 8179 case 3 : 8180 dbg.enterAlt(3); 8181 8182 // src/com/google/doclava/parser/Java.g:891:13: 'finally' block 8183 { 8184 dbg.location(891,13); 8185 match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4605); if (state.failed) return ; 8186 dbg.location(891,23); 8187 pushFollow(FOLLOW_block_in_trystatement4607); 8188 block(); 8189 8190 state._fsp--; 8191 if (state.failed) return ; 8192 8193 } 8194 break; 8195 8196 } 8197 } finally {dbg.exitSubRule(102);} 8198 8199 8200 } 8201 8202 } 8203 catch (RecognitionException re) { 8204 reportError(re); 8205 recover(input,re); 8206 } 8207 finally { 8208 if ( state.backtracking>0 ) { memoize(input, 62, trystatement_StartIndex); } 8209 } 8210 dbg.location(893, 6); 8211 8212 } 8213 finally { 8214 dbg.exitRule(getGrammarFileName(), "trystatement"); 8215 decRuleLevel(); 8216 if ( getRuleLevel()==0 ) {dbg.terminate();} 8217 } 8218 8219 return ; 8220 } 8221 // $ANTLR end "trystatement" 8222 8223 8224 // $ANTLR start "catches" 8225 // src/com/google/doclava/parser/Java.g:895:1: catches : catchClause ( catchClause )* ; catches()8226 public final void catches() throws RecognitionException { 8227 int catches_StartIndex = input.index(); 8228 try { dbg.enterRule(getGrammarFileName(), "catches"); 8229 if ( getRuleLevel()==0 ) {dbg.commence();} 8230 incRuleLevel(); 8231 dbg.location(895, 1); 8232 8233 try { 8234 if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; } 8235 // src/com/google/doclava/parser/Java.g:896:5: ( catchClause ( catchClause )* ) 8236 dbg.enterAlt(1); 8237 8238 // src/com/google/doclava/parser/Java.g:896:9: catchClause ( catchClause )* 8239 { 8240 dbg.location(896,9); 8241 pushFollow(FOLLOW_catchClause_in_catches4637); 8242 catchClause(); 8243 8244 state._fsp--; 8245 if (state.failed) return ; 8246 dbg.location(897,9); 8247 // src/com/google/doclava/parser/Java.g:897:9: ( catchClause )* 8248 try { dbg.enterSubRule(103); 8249 8250 loop103: 8251 do { 8252 int alt103=2; 8253 try { dbg.enterDecision(103, decisionCanBacktrack[103]); 8254 8255 int LA103_0 = input.LA(1); 8256 8257 if ( (LA103_0==CATCH) ) { 8258 alt103=1; 8259 } 8260 8261 8262 } finally {dbg.exitDecision(103);} 8263 8264 switch (alt103) { 8265 case 1 : 8266 dbg.enterAlt(1); 8267 8268 // src/com/google/doclava/parser/Java.g:897:10: catchClause 8269 { 8270 dbg.location(897,10); 8271 pushFollow(FOLLOW_catchClause_in_catches4648); 8272 catchClause(); 8273 8274 state._fsp--; 8275 if (state.failed) return ; 8276 8277 } 8278 break; 8279 8280 default : 8281 break loop103; 8282 } 8283 } while (true); 8284 } finally {dbg.exitSubRule(103);} 8285 8286 8287 } 8288 8289 } 8290 catch (RecognitionException re) { 8291 reportError(re); 8292 recover(input,re); 8293 } 8294 finally { 8295 if ( state.backtracking>0 ) { memoize(input, 63, catches_StartIndex); } 8296 } 8297 dbg.location(899, 5); 8298 8299 } 8300 finally { 8301 dbg.exitRule(getGrammarFileName(), "catches"); 8302 decRuleLevel(); 8303 if ( getRuleLevel()==0 ) {dbg.terminate();} 8304 } 8305 8306 return ; 8307 } 8308 // $ANTLR end "catches" 8309 8310 8311 // $ANTLR start "catchClause" 8312 // src/com/google/doclava/parser/Java.g:901:1: catchClause : 'catch' '(' formalParameter ')' block ; catchClause()8313 public final void catchClause() throws RecognitionException { 8314 int catchClause_StartIndex = input.index(); 8315 try { dbg.enterRule(getGrammarFileName(), "catchClause"); 8316 if ( getRuleLevel()==0 ) {dbg.commence();} 8317 incRuleLevel(); 8318 dbg.location(901, 1); 8319 8320 try { 8321 if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; } 8322 // src/com/google/doclava/parser/Java.g:902:5: ( 'catch' '(' formalParameter ')' block ) 8323 dbg.enterAlt(1); 8324 8325 // src/com/google/doclava/parser/Java.g:902:9: 'catch' '(' formalParameter ')' block 8326 { 8327 dbg.location(902,9); 8328 match(input,CATCH,FOLLOW_CATCH_in_catchClause4678); if (state.failed) return ; 8329 dbg.location(902,17); 8330 match(input,LPAREN,FOLLOW_LPAREN_in_catchClause4680); if (state.failed) return ; 8331 dbg.location(902,21); 8332 pushFollow(FOLLOW_formalParameter_in_catchClause4682); 8333 formalParameter(); 8334 8335 state._fsp--; 8336 if (state.failed) return ; 8337 dbg.location(903,9); 8338 match(input,RPAREN,FOLLOW_RPAREN_in_catchClause4692); if (state.failed) return ; 8339 dbg.location(903,13); 8340 pushFollow(FOLLOW_block_in_catchClause4694); 8341 block(); 8342 8343 state._fsp--; 8344 if (state.failed) return ; 8345 8346 } 8347 8348 } 8349 catch (RecognitionException re) { 8350 reportError(re); 8351 recover(input,re); 8352 } 8353 finally { 8354 if ( state.backtracking>0 ) { memoize(input, 64, catchClause_StartIndex); } 8355 } 8356 dbg.location(904, 5); 8357 8358 } 8359 finally { 8360 dbg.exitRule(getGrammarFileName(), "catchClause"); 8361 decRuleLevel(); 8362 if ( getRuleLevel()==0 ) {dbg.terminate();} 8363 } 8364 8365 return ; 8366 } 8367 // $ANTLR end "catchClause" 8368 8369 8370 // $ANTLR start "formalParameter" 8371 // src/com/google/doclava/parser/Java.g:906:1: formalParameter : variableModifiers type IDENTIFIER ( '[' ']' )* ; formalParameter()8372 public final void formalParameter() throws RecognitionException { 8373 int formalParameter_StartIndex = input.index(); 8374 try { dbg.enterRule(getGrammarFileName(), "formalParameter"); 8375 if ( getRuleLevel()==0 ) {dbg.commence();} 8376 incRuleLevel(); 8377 dbg.location(906, 1); 8378 8379 try { 8380 if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; } 8381 // src/com/google/doclava/parser/Java.g:907:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ) 8382 dbg.enterAlt(1); 8383 8384 // src/com/google/doclava/parser/Java.g:907:9: variableModifiers type IDENTIFIER ( '[' ']' )* 8385 { 8386 dbg.location(907,9); 8387 pushFollow(FOLLOW_variableModifiers_in_formalParameter4713); 8388 variableModifiers(); 8389 8390 state._fsp--; 8391 if (state.failed) return ; 8392 dbg.location(907,27); 8393 pushFollow(FOLLOW_type_in_formalParameter4715); 8394 type(); 8395 8396 state._fsp--; 8397 if (state.failed) return ; 8398 dbg.location(907,32); 8399 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_formalParameter4717); if (state.failed) return ; 8400 dbg.location(908,9); 8401 // src/com/google/doclava/parser/Java.g:908:9: ( '[' ']' )* 8402 try { dbg.enterSubRule(104); 8403 8404 loop104: 8405 do { 8406 int alt104=2; 8407 try { dbg.enterDecision(104, decisionCanBacktrack[104]); 8408 8409 int LA104_0 = input.LA(1); 8410 8411 if ( (LA104_0==LBRACKET) ) { 8412 alt104=1; 8413 } 8414 8415 8416 } finally {dbg.exitDecision(104);} 8417 8418 switch (alt104) { 8419 case 1 : 8420 dbg.enterAlt(1); 8421 8422 // src/com/google/doclava/parser/Java.g:908:10: '[' ']' 8423 { 8424 dbg.location(908,10); 8425 match(input,LBRACKET,FOLLOW_LBRACKET_in_formalParameter4728); if (state.failed) return ; 8426 dbg.location(908,14); 8427 match(input,RBRACKET,FOLLOW_RBRACKET_in_formalParameter4730); if (state.failed) return ; 8428 8429 } 8430 break; 8431 8432 default : 8433 break loop104; 8434 } 8435 } while (true); 8436 } finally {dbg.exitSubRule(104);} 8437 8438 8439 } 8440 8441 } 8442 catch (RecognitionException re) { 8443 reportError(re); 8444 recover(input,re); 8445 } 8446 finally { 8447 if ( state.backtracking>0 ) { memoize(input, 65, formalParameter_StartIndex); } 8448 } 8449 dbg.location(910, 5); 8450 8451 } 8452 finally { 8453 dbg.exitRule(getGrammarFileName(), "formalParameter"); 8454 decRuleLevel(); 8455 if ( getRuleLevel()==0 ) {dbg.terminate();} 8456 } 8457 8458 return ; 8459 } 8460 // $ANTLR end "formalParameter" 8461 8462 8463 // $ANTLR start "forstatement" 8464 // src/com/google/doclava/parser/Java.g:912:1: forstatement : ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement ); forstatement()8465 public final void forstatement() throws RecognitionException { 8466 int forstatement_StartIndex = input.index(); 8467 try { dbg.enterRule(getGrammarFileName(), "forstatement"); 8468 if ( getRuleLevel()==0 ) {dbg.commence();} 8469 incRuleLevel(); 8470 dbg.location(912, 1); 8471 8472 try { 8473 if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; } 8474 // src/com/google/doclava/parser/Java.g:913:5: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement ) 8475 int alt108=2; 8476 try { dbg.enterDecision(108, decisionCanBacktrack[108]); 8477 8478 int LA108_0 = input.LA(1); 8479 8480 if ( (LA108_0==FOR) ) { 8481 int LA108_1 = input.LA(2); 8482 8483 if ( (synpred157_Java()) ) { 8484 alt108=1; 8485 } 8486 else if ( (true) ) { 8487 alt108=2; 8488 } 8489 else { 8490 if (state.backtracking>0) {state.failed=true; return ;} 8491 NoViableAltException nvae = 8492 new NoViableAltException("", 108, 1, input); 8493 8494 dbg.recognitionException(nvae); 8495 throw nvae; 8496 } 8497 } 8498 else { 8499 if (state.backtracking>0) {state.failed=true; return ;} 8500 NoViableAltException nvae = 8501 new NoViableAltException("", 108, 0, input); 8502 8503 dbg.recognitionException(nvae); 8504 throw nvae; 8505 } 8506 } finally {dbg.exitDecision(108);} 8507 8508 switch (alt108) { 8509 case 1 : 8510 dbg.enterAlt(1); 8511 8512 // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement 8513 { 8514 dbg.location(915,9); 8515 match(input,FOR,FOLLOW_FOR_in_forstatement4775); if (state.failed) return ; 8516 dbg.location(915,15); 8517 match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4777); if (state.failed) return ; 8518 dbg.location(915,19); 8519 pushFollow(FOLLOW_variableModifiers_in_forstatement4779); 8520 variableModifiers(); 8521 8522 state._fsp--; 8523 if (state.failed) return ; 8524 dbg.location(915,37); 8525 pushFollow(FOLLOW_type_in_forstatement4781); 8526 type(); 8527 8528 state._fsp--; 8529 if (state.failed) return ; 8530 dbg.location(915,42); 8531 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forstatement4783); if (state.failed) return ; 8532 dbg.location(915,53); 8533 match(input,COLON,FOLLOW_COLON_in_forstatement4785); if (state.failed) return ; 8534 dbg.location(916,9); 8535 pushFollow(FOLLOW_expression_in_forstatement4795); 8536 expression(); 8537 8538 state._fsp--; 8539 if (state.failed) return ; 8540 dbg.location(916,20); 8541 match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4797); if (state.failed) return ; 8542 dbg.location(916,24); 8543 pushFollow(FOLLOW_statement_in_forstatement4799); 8544 statement(); 8545 8546 state._fsp--; 8547 if (state.failed) return ; 8548 8549 } 8550 break; 8551 case 2 : 8552 dbg.enterAlt(2); 8553 8554 // src/com/google/doclava/parser/Java.g:919:9: 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement 8555 { 8556 dbg.location(919,9); 8557 match(input,FOR,FOLLOW_FOR_in_forstatement4819); if (state.failed) return ; 8558 dbg.location(919,15); 8559 match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4821); if (state.failed) return ; 8560 dbg.location(920,17); 8561 // src/com/google/doclava/parser/Java.g:920:17: ( forInit )? 8562 int alt105=2; 8563 try { dbg.enterSubRule(105); 8564 try { dbg.enterDecision(105, decisionCanBacktrack[105]); 8565 8566 int LA105_0 = input.LA(1); 8567 8568 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) ) { 8569 alt105=1; 8570 } 8571 } finally {dbg.exitDecision(105);} 8572 8573 switch (alt105) { 8574 case 1 : 8575 dbg.enterAlt(1); 8576 8577 // src/com/google/doclava/parser/Java.g:920:18: forInit 8578 { 8579 dbg.location(920,18); 8580 pushFollow(FOLLOW_forInit_in_forstatement4840); 8581 forInit(); 8582 8583 state._fsp--; 8584 if (state.failed) return ; 8585 8586 } 8587 break; 8588 8589 } 8590 } finally {dbg.exitSubRule(105);} 8591 8592 dbg.location(921,20); 8593 match(input,SEMI,FOLLOW_SEMI_in_forstatement4861); if (state.failed) return ; 8594 dbg.location(922,17); 8595 // src/com/google/doclava/parser/Java.g:922:17: ( expression )? 8596 int alt106=2; 8597 try { dbg.enterSubRule(106); 8598 try { dbg.enterDecision(106, decisionCanBacktrack[106]); 8599 8600 int LA106_0 = input.LA(1); 8601 8602 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)) ) { 8603 alt106=1; 8604 } 8605 } finally {dbg.exitDecision(106);} 8606 8607 switch (alt106) { 8608 case 1 : 8609 dbg.enterAlt(1); 8610 8611 // src/com/google/doclava/parser/Java.g:922:18: expression 8612 { 8613 dbg.location(922,18); 8614 pushFollow(FOLLOW_expression_in_forstatement4880); 8615 expression(); 8616 8617 state._fsp--; 8618 if (state.failed) return ; 8619 8620 } 8621 break; 8622 8623 } 8624 } finally {dbg.exitSubRule(106);} 8625 8626 dbg.location(923,20); 8627 match(input,SEMI,FOLLOW_SEMI_in_forstatement4901); if (state.failed) return ; 8628 dbg.location(924,17); 8629 // src/com/google/doclava/parser/Java.g:924:17: ( expressionList )? 8630 int alt107=2; 8631 try { dbg.enterSubRule(107); 8632 try { dbg.enterDecision(107, decisionCanBacktrack[107]); 8633 8634 int LA107_0 = input.LA(1); 8635 8636 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)) ) { 8637 alt107=1; 8638 } 8639 } finally {dbg.exitDecision(107);} 8640 8641 switch (alt107) { 8642 case 1 : 8643 dbg.enterAlt(1); 8644 8645 // src/com/google/doclava/parser/Java.g:924:18: expressionList 8646 { 8647 dbg.location(924,18); 8648 pushFollow(FOLLOW_expressionList_in_forstatement4920); 8649 expressionList(); 8650 8651 state._fsp--; 8652 if (state.failed) return ; 8653 8654 } 8655 break; 8656 8657 } 8658 } finally {dbg.exitSubRule(107);} 8659 8660 dbg.location(925,20); 8661 match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4941); if (state.failed) return ; 8662 dbg.location(925,24); 8663 pushFollow(FOLLOW_statement_in_forstatement4943); 8664 statement(); 8665 8666 state._fsp--; 8667 if (state.failed) return ; 8668 8669 } 8670 break; 8671 8672 } 8673 } 8674 catch (RecognitionException re) { 8675 reportError(re); 8676 recover(input,re); 8677 } 8678 finally { 8679 if ( state.backtracking>0 ) { memoize(input, 66, forstatement_StartIndex); } 8680 } 8681 dbg.location(926, 5); 8682 8683 } 8684 finally { 8685 dbg.exitRule(getGrammarFileName(), "forstatement"); 8686 decRuleLevel(); 8687 if ( getRuleLevel()==0 ) {dbg.terminate();} 8688 } 8689 8690 return ; 8691 } 8692 // $ANTLR end "forstatement" 8693 8694 8695 // $ANTLR start "forInit" 8696 // src/com/google/doclava/parser/Java.g:928:1: forInit : ( localVariableDeclaration | expressionList ); forInit()8697 public final void forInit() throws RecognitionException { 8698 int forInit_StartIndex = input.index(); 8699 try { dbg.enterRule(getGrammarFileName(), "forInit"); 8700 if ( getRuleLevel()==0 ) {dbg.commence();} 8701 incRuleLevel(); 8702 dbg.location(928, 1); 8703 8704 try { 8705 if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; } 8706 // src/com/google/doclava/parser/Java.g:929:5: ( localVariableDeclaration | expressionList ) 8707 int alt109=2; 8708 try { dbg.enterDecision(109, decisionCanBacktrack[109]); 8709 8710 try { 8711 isCyclicDecision = true; 8712 alt109 = dfa109.predict(input); 8713 } 8714 catch (NoViableAltException nvae) { 8715 dbg.recognitionException(nvae); 8716 throw nvae; 8717 } 8718 } finally {dbg.exitDecision(109);} 8719 8720 switch (alt109) { 8721 case 1 : 8722 dbg.enterAlt(1); 8723 8724 // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration 8725 { 8726 dbg.location(929,9); 8727 pushFollow(FOLLOW_localVariableDeclaration_in_forInit4962); 8728 localVariableDeclaration(); 8729 8730 state._fsp--; 8731 if (state.failed) return ; 8732 8733 } 8734 break; 8735 case 2 : 8736 dbg.enterAlt(2); 8737 8738 // src/com/google/doclava/parser/Java.g:930:9: expressionList 8739 { 8740 dbg.location(930,9); 8741 pushFollow(FOLLOW_expressionList_in_forInit4972); 8742 expressionList(); 8743 8744 state._fsp--; 8745 if (state.failed) return ; 8746 8747 } 8748 break; 8749 8750 } 8751 } 8752 catch (RecognitionException re) { 8753 reportError(re); 8754 recover(input,re); 8755 } 8756 finally { 8757 if ( state.backtracking>0 ) { memoize(input, 67, forInit_StartIndex); } 8758 } 8759 dbg.location(931, 5); 8760 8761 } 8762 finally { 8763 dbg.exitRule(getGrammarFileName(), "forInit"); 8764 decRuleLevel(); 8765 if ( getRuleLevel()==0 ) {dbg.terminate();} 8766 } 8767 8768 return ; 8769 } 8770 // $ANTLR end "forInit" 8771 8772 8773 // $ANTLR start "parExpression" 8774 // src/com/google/doclava/parser/Java.g:933:1: parExpression : '(' expression ')' ; parExpression()8775 public final void parExpression() throws RecognitionException { 8776 int parExpression_StartIndex = input.index(); 8777 try { dbg.enterRule(getGrammarFileName(), "parExpression"); 8778 if ( getRuleLevel()==0 ) {dbg.commence();} 8779 incRuleLevel(); 8780 dbg.location(933, 1); 8781 8782 try { 8783 if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; } 8784 // src/com/google/doclava/parser/Java.g:934:5: ( '(' expression ')' ) 8785 dbg.enterAlt(1); 8786 8787 // src/com/google/doclava/parser/Java.g:934:9: '(' expression ')' 8788 { 8789 dbg.location(934,9); 8790 match(input,LPAREN,FOLLOW_LPAREN_in_parExpression4991); if (state.failed) return ; 8791 dbg.location(934,13); 8792 pushFollow(FOLLOW_expression_in_parExpression4993); 8793 expression(); 8794 8795 state._fsp--; 8796 if (state.failed) return ; 8797 dbg.location(934,24); 8798 match(input,RPAREN,FOLLOW_RPAREN_in_parExpression4995); if (state.failed) return ; 8799 8800 } 8801 8802 } 8803 catch (RecognitionException re) { 8804 reportError(re); 8805 recover(input,re); 8806 } 8807 finally { 8808 if ( state.backtracking>0 ) { memoize(input, 68, parExpression_StartIndex); } 8809 } 8810 dbg.location(935, 5); 8811 8812 } 8813 finally { 8814 dbg.exitRule(getGrammarFileName(), "parExpression"); 8815 decRuleLevel(); 8816 if ( getRuleLevel()==0 ) {dbg.terminate();} 8817 } 8818 8819 return ; 8820 } 8821 // $ANTLR end "parExpression" 8822 8823 8824 // $ANTLR start "expressionList" 8825 // src/com/google/doclava/parser/Java.g:937:1: expressionList : expression ( ',' expression )* ; expressionList()8826 public final void expressionList() throws RecognitionException { 8827 int expressionList_StartIndex = input.index(); 8828 try { dbg.enterRule(getGrammarFileName(), "expressionList"); 8829 if ( getRuleLevel()==0 ) {dbg.commence();} 8830 incRuleLevel(); 8831 dbg.location(937, 1); 8832 8833 try { 8834 if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; } 8835 // src/com/google/doclava/parser/Java.g:938:5: ( expression ( ',' expression )* ) 8836 dbg.enterAlt(1); 8837 8838 // src/com/google/doclava/parser/Java.g:938:9: expression ( ',' expression )* 8839 { 8840 dbg.location(938,9); 8841 pushFollow(FOLLOW_expression_in_expressionList5014); 8842 expression(); 8843 8844 state._fsp--; 8845 if (state.failed) return ; 8846 dbg.location(939,9); 8847 // src/com/google/doclava/parser/Java.g:939:9: ( ',' expression )* 8848 try { dbg.enterSubRule(110); 8849 8850 loop110: 8851 do { 8852 int alt110=2; 8853 try { dbg.enterDecision(110, decisionCanBacktrack[110]); 8854 8855 int LA110_0 = input.LA(1); 8856 8857 if ( (LA110_0==COMMA) ) { 8858 alt110=1; 8859 } 8860 8861 8862 } finally {dbg.exitDecision(110);} 8863 8864 switch (alt110) { 8865 case 1 : 8866 dbg.enterAlt(1); 8867 8868 // src/com/google/doclava/parser/Java.g:939:10: ',' expression 8869 { 8870 dbg.location(939,10); 8871 match(input,COMMA,FOLLOW_COMMA_in_expressionList5025); if (state.failed) return ; 8872 dbg.location(939,14); 8873 pushFollow(FOLLOW_expression_in_expressionList5027); 8874 expression(); 8875 8876 state._fsp--; 8877 if (state.failed) return ; 8878 8879 } 8880 break; 8881 8882 default : 8883 break loop110; 8884 } 8885 } while (true); 8886 } finally {dbg.exitSubRule(110);} 8887 8888 8889 } 8890 8891 } 8892 catch (RecognitionException re) { 8893 reportError(re); 8894 recover(input,re); 8895 } 8896 finally { 8897 if ( state.backtracking>0 ) { memoize(input, 69, expressionList_StartIndex); } 8898 } 8899 dbg.location(941, 5); 8900 8901 } 8902 finally { 8903 dbg.exitRule(getGrammarFileName(), "expressionList"); 8904 decRuleLevel(); 8905 if ( getRuleLevel()==0 ) {dbg.terminate();} 8906 } 8907 8908 return ; 8909 } 8910 // $ANTLR end "expressionList" 8911 8912 8913 // $ANTLR start "expression" 8914 // src/com/google/doclava/parser/Java.g:944:1: expression : conditionalExpression ( assignmentOperator expression )? ; expression()8915 public final void expression() throws RecognitionException { 8916 int expression_StartIndex = input.index(); 8917 try { dbg.enterRule(getGrammarFileName(), "expression"); 8918 if ( getRuleLevel()==0 ) {dbg.commence();} 8919 incRuleLevel(); 8920 dbg.location(944, 1); 8921 8922 try { 8923 if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; } 8924 // src/com/google/doclava/parser/Java.g:945:5: ( conditionalExpression ( assignmentOperator expression )? ) 8925 dbg.enterAlt(1); 8926 8927 // src/com/google/doclava/parser/Java.g:945:9: conditionalExpression ( assignmentOperator expression )? 8928 { 8929 dbg.location(945,9); 8930 pushFollow(FOLLOW_conditionalExpression_in_expression5058); 8931 conditionalExpression(); 8932 8933 state._fsp--; 8934 if (state.failed) return ; 8935 dbg.location(946,9); 8936 // src/com/google/doclava/parser/Java.g:946:9: ( assignmentOperator expression )? 8937 int alt111=2; 8938 try { dbg.enterSubRule(111); 8939 try { dbg.enterDecision(111, decisionCanBacktrack[111]); 8940 8941 int LA111_0 = input.LA(1); 8942 8943 if ( (LA111_0==EQ||(LA111_0>=PLUSEQ && LA111_0<=PERCENTEQ)||(LA111_0>=GT && LA111_0<=LT)) ) { 8944 alt111=1; 8945 } 8946 } finally {dbg.exitDecision(111);} 8947 8948 switch (alt111) { 8949 case 1 : 8950 dbg.enterAlt(1); 8951 8952 // src/com/google/doclava/parser/Java.g:946:10: assignmentOperator expression 8953 { 8954 dbg.location(946,10); 8955 pushFollow(FOLLOW_assignmentOperator_in_expression5069); 8956 assignmentOperator(); 8957 8958 state._fsp--; 8959 if (state.failed) return ; 8960 dbg.location(946,29); 8961 pushFollow(FOLLOW_expression_in_expression5071); 8962 expression(); 8963 8964 state._fsp--; 8965 if (state.failed) return ; 8966 8967 } 8968 break; 8969 8970 } 8971 } finally {dbg.exitSubRule(111);} 8972 8973 8974 } 8975 8976 } 8977 catch (RecognitionException re) { 8978 reportError(re); 8979 recover(input,re); 8980 } 8981 finally { 8982 if ( state.backtracking>0 ) { memoize(input, 70, expression_StartIndex); } 8983 } 8984 dbg.location(948, 5); 8985 8986 } 8987 finally { 8988 dbg.exitRule(getGrammarFileName(), "expression"); 8989 decRuleLevel(); 8990 if ( getRuleLevel()==0 ) {dbg.terminate();} 8991 } 8992 8993 return ; 8994 } 8995 // $ANTLR end "expression" 8996 8997 8998 // $ANTLR start "assignmentOperator" 8999 // src/com/google/doclava/parser/Java.g:951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' ); assignmentOperator()9000 public final void assignmentOperator() throws RecognitionException { 9001 int assignmentOperator_StartIndex = input.index(); 9002 try { dbg.enterRule(getGrammarFileName(), "assignmentOperator"); 9003 if ( getRuleLevel()==0 ) {dbg.commence();} 9004 incRuleLevel(); 9005 dbg.location(951, 1); 9006 9007 try { 9008 if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; } 9009 // src/com/google/doclava/parser/Java.g:952:5: ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' ) 9010 int alt112=12; 9011 try { dbg.enterDecision(112, decisionCanBacktrack[112]); 9012 9013 try { 9014 isCyclicDecision = true; 9015 alt112 = dfa112.predict(input); 9016 } 9017 catch (NoViableAltException nvae) { 9018 dbg.recognitionException(nvae); 9019 throw nvae; 9020 } 9021 } finally {dbg.exitDecision(112);} 9022 9023 switch (alt112) { 9024 case 1 : 9025 dbg.enterAlt(1); 9026 9027 // src/com/google/doclava/parser/Java.g:952:9: '=' 9028 { 9029 dbg.location(952,9); 9030 match(input,EQ,FOLLOW_EQ_in_assignmentOperator5102); if (state.failed) return ; 9031 9032 } 9033 break; 9034 case 2 : 9035 dbg.enterAlt(2); 9036 9037 // src/com/google/doclava/parser/Java.g:953:9: '+=' 9038 { 9039 dbg.location(953,9); 9040 match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignmentOperator5112); if (state.failed) return ; 9041 9042 } 9043 break; 9044 case 3 : 9045 dbg.enterAlt(3); 9046 9047 // src/com/google/doclava/parser/Java.g:954:9: '-=' 9048 { 9049 dbg.location(954,9); 9050 match(input,SUBEQ,FOLLOW_SUBEQ_in_assignmentOperator5122); if (state.failed) return ; 9051 9052 } 9053 break; 9054 case 4 : 9055 dbg.enterAlt(4); 9056 9057 // src/com/google/doclava/parser/Java.g:955:9: '*=' 9058 { 9059 dbg.location(955,9); 9060 match(input,STAREQ,FOLLOW_STAREQ_in_assignmentOperator5132); if (state.failed) return ; 9061 9062 } 9063 break; 9064 case 5 : 9065 dbg.enterAlt(5); 9066 9067 // src/com/google/doclava/parser/Java.g:956:9: '/=' 9068 { 9069 dbg.location(956,9); 9070 match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignmentOperator5142); if (state.failed) return ; 9071 9072 } 9073 break; 9074 case 6 : 9075 dbg.enterAlt(6); 9076 9077 // src/com/google/doclava/parser/Java.g:957:9: '&=' 9078 { 9079 dbg.location(957,9); 9080 match(input,AMPEQ,FOLLOW_AMPEQ_in_assignmentOperator5152); if (state.failed) return ; 9081 9082 } 9083 break; 9084 case 7 : 9085 dbg.enterAlt(7); 9086 9087 // src/com/google/doclava/parser/Java.g:958:9: '|=' 9088 { 9089 dbg.location(958,9); 9090 match(input,BAREQ,FOLLOW_BAREQ_in_assignmentOperator5162); if (state.failed) return ; 9091 9092 } 9093 break; 9094 case 8 : 9095 dbg.enterAlt(8); 9096 9097 // src/com/google/doclava/parser/Java.g:959:9: '^=' 9098 { 9099 dbg.location(959,9); 9100 match(input,CARETEQ,FOLLOW_CARETEQ_in_assignmentOperator5172); if (state.failed) return ; 9101 9102 } 9103 break; 9104 case 9 : 9105 dbg.enterAlt(9); 9106 9107 // src/com/google/doclava/parser/Java.g:960:9: '%=' 9108 { 9109 dbg.location(960,9); 9110 match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignmentOperator5182); if (state.failed) return ; 9111 9112 } 9113 break; 9114 case 10 : 9115 dbg.enterAlt(10); 9116 9117 // src/com/google/doclava/parser/Java.g:961:10: '<' '<' '=' 9118 { 9119 dbg.location(961,10); 9120 match(input,LT,FOLLOW_LT_in_assignmentOperator5193); if (state.failed) return ; 9121 dbg.location(961,14); 9122 match(input,LT,FOLLOW_LT_in_assignmentOperator5195); if (state.failed) return ; 9123 dbg.location(961,18); 9124 match(input,EQ,FOLLOW_EQ_in_assignmentOperator5197); if (state.failed) return ; 9125 9126 } 9127 break; 9128 case 11 : 9129 dbg.enterAlt(11); 9130 9131 // src/com/google/doclava/parser/Java.g:962:10: '>' '>' '>' '=' 9132 { 9133 dbg.location(962,10); 9134 match(input,GT,FOLLOW_GT_in_assignmentOperator5208); if (state.failed) return ; 9135 dbg.location(962,14); 9136 match(input,GT,FOLLOW_GT_in_assignmentOperator5210); if (state.failed) return ; 9137 dbg.location(962,18); 9138 match(input,GT,FOLLOW_GT_in_assignmentOperator5212); if (state.failed) return ; 9139 dbg.location(962,22); 9140 match(input,EQ,FOLLOW_EQ_in_assignmentOperator5214); if (state.failed) return ; 9141 9142 } 9143 break; 9144 case 12 : 9145 dbg.enterAlt(12); 9146 9147 // src/com/google/doclava/parser/Java.g:963:10: '>' '>' '=' 9148 { 9149 dbg.location(963,10); 9150 match(input,GT,FOLLOW_GT_in_assignmentOperator5225); if (state.failed) return ; 9151 dbg.location(963,14); 9152 match(input,GT,FOLLOW_GT_in_assignmentOperator5227); if (state.failed) return ; 9153 dbg.location(963,18); 9154 match(input,EQ,FOLLOW_EQ_in_assignmentOperator5229); if (state.failed) return ; 9155 9156 } 9157 break; 9158 9159 } 9160 } 9161 catch (RecognitionException re) { 9162 reportError(re); 9163 recover(input,re); 9164 } 9165 finally { 9166 if ( state.backtracking>0 ) { memoize(input, 71, assignmentOperator_StartIndex); } 9167 } 9168 dbg.location(964, 5); 9169 9170 } 9171 finally { 9172 dbg.exitRule(getGrammarFileName(), "assignmentOperator"); 9173 decRuleLevel(); 9174 if ( getRuleLevel()==0 ) {dbg.terminate();} 9175 } 9176 9177 return ; 9178 } 9179 // $ANTLR end "assignmentOperator" 9180 9181 9182 // $ANTLR start "conditionalExpression" 9183 // src/com/google/doclava/parser/Java.g:967:1: conditionalExpression : conditionalOrExpression ( '?' expression ':' conditionalExpression )? ; conditionalExpression()9184 public final void conditionalExpression() throws RecognitionException { 9185 int conditionalExpression_StartIndex = input.index(); 9186 try { dbg.enterRule(getGrammarFileName(), "conditionalExpression"); 9187 if ( getRuleLevel()==0 ) {dbg.commence();} 9188 incRuleLevel(); 9189 dbg.location(967, 1); 9190 9191 try { 9192 if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; } 9193 // src/com/google/doclava/parser/Java.g:968:5: ( conditionalOrExpression ( '?' expression ':' conditionalExpression )? ) 9194 dbg.enterAlt(1); 9195 9196 // src/com/google/doclava/parser/Java.g:968:9: conditionalOrExpression ( '?' expression ':' conditionalExpression )? 9197 { 9198 dbg.location(968,9); 9199 pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression5249); 9200 conditionalOrExpression(); 9201 9202 state._fsp--; 9203 if (state.failed) return ; 9204 dbg.location(969,9); 9205 // src/com/google/doclava/parser/Java.g:969:9: ( '?' expression ':' conditionalExpression )? 9206 int alt113=2; 9207 try { dbg.enterSubRule(113); 9208 try { dbg.enterDecision(113, decisionCanBacktrack[113]); 9209 9210 int LA113_0 = input.LA(1); 9211 9212 if ( (LA113_0==QUES) ) { 9213 alt113=1; 9214 } 9215 } finally {dbg.exitDecision(113);} 9216 9217 switch (alt113) { 9218 case 1 : 9219 dbg.enterAlt(1); 9220 9221 // src/com/google/doclava/parser/Java.g:969:10: '?' expression ':' conditionalExpression 9222 { 9223 dbg.location(969,10); 9224 match(input,QUES,FOLLOW_QUES_in_conditionalExpression5260); if (state.failed) return ; 9225 dbg.location(969,14); 9226 pushFollow(FOLLOW_expression_in_conditionalExpression5262); 9227 expression(); 9228 9229 state._fsp--; 9230 if (state.failed) return ; 9231 dbg.location(969,25); 9232 match(input,COLON,FOLLOW_COLON_in_conditionalExpression5264); if (state.failed) return ; 9233 dbg.location(969,29); 9234 pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression5266); 9235 conditionalExpression(); 9236 9237 state._fsp--; 9238 if (state.failed) return ; 9239 9240 } 9241 break; 9242 9243 } 9244 } finally {dbg.exitSubRule(113);} 9245 9246 9247 } 9248 9249 } 9250 catch (RecognitionException re) { 9251 reportError(re); 9252 recover(input,re); 9253 } 9254 finally { 9255 if ( state.backtracking>0 ) { memoize(input, 72, conditionalExpression_StartIndex); } 9256 } 9257 dbg.location(971, 5); 9258 9259 } 9260 finally { 9261 dbg.exitRule(getGrammarFileName(), "conditionalExpression"); 9262 decRuleLevel(); 9263 if ( getRuleLevel()==0 ) {dbg.terminate();} 9264 } 9265 9266 return ; 9267 } 9268 // $ANTLR end "conditionalExpression" 9269 9270 9271 // $ANTLR start "conditionalOrExpression" 9272 // src/com/google/doclava/parser/Java.g:973:1: conditionalOrExpression : conditionalAndExpression ( '||' conditionalAndExpression )* ; conditionalOrExpression()9273 public final void conditionalOrExpression() throws RecognitionException { 9274 int conditionalOrExpression_StartIndex = input.index(); 9275 try { dbg.enterRule(getGrammarFileName(), "conditionalOrExpression"); 9276 if ( getRuleLevel()==0 ) {dbg.commence();} 9277 incRuleLevel(); 9278 dbg.location(973, 1); 9279 9280 try { 9281 if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; } 9282 // src/com/google/doclava/parser/Java.g:974:5: ( conditionalAndExpression ( '||' conditionalAndExpression )* ) 9283 dbg.enterAlt(1); 9284 9285 // src/com/google/doclava/parser/Java.g:974:9: conditionalAndExpression ( '||' conditionalAndExpression )* 9286 { 9287 dbg.location(974,9); 9288 pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296); 9289 conditionalAndExpression(); 9290 9291 state._fsp--; 9292 if (state.failed) return ; 9293 dbg.location(975,9); 9294 // src/com/google/doclava/parser/Java.g:975:9: ( '||' conditionalAndExpression )* 9295 try { dbg.enterSubRule(114); 9296 9297 loop114: 9298 do { 9299 int alt114=2; 9300 try { dbg.enterDecision(114, decisionCanBacktrack[114]); 9301 9302 int LA114_0 = input.LA(1); 9303 9304 if ( (LA114_0==BARBAR) ) { 9305 alt114=1; 9306 } 9307 9308 9309 } finally {dbg.exitDecision(114);} 9310 9311 switch (alt114) { 9312 case 1 : 9313 dbg.enterAlt(1); 9314 9315 // src/com/google/doclava/parser/Java.g:975:10: '||' conditionalAndExpression 9316 { 9317 dbg.location(975,10); 9318 match(input,BARBAR,FOLLOW_BARBAR_in_conditionalOrExpression5307); if (state.failed) return ; 9319 dbg.location(975,15); 9320 pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309); 9321 conditionalAndExpression(); 9322 9323 state._fsp--; 9324 if (state.failed) return ; 9325 9326 } 9327 break; 9328 9329 default : 9330 break loop114; 9331 } 9332 } while (true); 9333 } finally {dbg.exitSubRule(114);} 9334 9335 9336 } 9337 9338 } 9339 catch (RecognitionException re) { 9340 reportError(re); 9341 recover(input,re); 9342 } 9343 finally { 9344 if ( state.backtracking>0 ) { memoize(input, 73, conditionalOrExpression_StartIndex); } 9345 } 9346 dbg.location(977, 5); 9347 9348 } 9349 finally { 9350 dbg.exitRule(getGrammarFileName(), "conditionalOrExpression"); 9351 decRuleLevel(); 9352 if ( getRuleLevel()==0 ) {dbg.terminate();} 9353 } 9354 9355 return ; 9356 } 9357 // $ANTLR end "conditionalOrExpression" 9358 9359 9360 // $ANTLR start "conditionalAndExpression" 9361 // src/com/google/doclava/parser/Java.g:979:1: conditionalAndExpression : inclusiveOrExpression ( '&&' inclusiveOrExpression )* ; conditionalAndExpression()9362 public final void conditionalAndExpression() throws RecognitionException { 9363 int conditionalAndExpression_StartIndex = input.index(); 9364 try { dbg.enterRule(getGrammarFileName(), "conditionalAndExpression"); 9365 if ( getRuleLevel()==0 ) {dbg.commence();} 9366 incRuleLevel(); 9367 dbg.location(979, 1); 9368 9369 try { 9370 if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; } 9371 // src/com/google/doclava/parser/Java.g:980:5: ( inclusiveOrExpression ( '&&' inclusiveOrExpression )* ) 9372 dbg.enterAlt(1); 9373 9374 // src/com/google/doclava/parser/Java.g:980:9: inclusiveOrExpression ( '&&' inclusiveOrExpression )* 9375 { 9376 dbg.location(980,9); 9377 pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339); 9378 inclusiveOrExpression(); 9379 9380 state._fsp--; 9381 if (state.failed) return ; 9382 dbg.location(981,9); 9383 // src/com/google/doclava/parser/Java.g:981:9: ( '&&' inclusiveOrExpression )* 9384 try { dbg.enterSubRule(115); 9385 9386 loop115: 9387 do { 9388 int alt115=2; 9389 try { dbg.enterDecision(115, decisionCanBacktrack[115]); 9390 9391 int LA115_0 = input.LA(1); 9392 9393 if ( (LA115_0==AMPAMP) ) { 9394 alt115=1; 9395 } 9396 9397 9398 } finally {dbg.exitDecision(115);} 9399 9400 switch (alt115) { 9401 case 1 : 9402 dbg.enterAlt(1); 9403 9404 // src/com/google/doclava/parser/Java.g:981:10: '&&' inclusiveOrExpression 9405 { 9406 dbg.location(981,10); 9407 match(input,AMPAMP,FOLLOW_AMPAMP_in_conditionalAndExpression5350); if (state.failed) return ; 9408 dbg.location(981,15); 9409 pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352); 9410 inclusiveOrExpression(); 9411 9412 state._fsp--; 9413 if (state.failed) return ; 9414 9415 } 9416 break; 9417 9418 default : 9419 break loop115; 9420 } 9421 } while (true); 9422 } finally {dbg.exitSubRule(115);} 9423 9424 9425 } 9426 9427 } 9428 catch (RecognitionException re) { 9429 reportError(re); 9430 recover(input,re); 9431 } 9432 finally { 9433 if ( state.backtracking>0 ) { memoize(input, 74, conditionalAndExpression_StartIndex); } 9434 } 9435 dbg.location(983, 5); 9436 9437 } 9438 finally { 9439 dbg.exitRule(getGrammarFileName(), "conditionalAndExpression"); 9440 decRuleLevel(); 9441 if ( getRuleLevel()==0 ) {dbg.terminate();} 9442 } 9443 9444 return ; 9445 } 9446 // $ANTLR end "conditionalAndExpression" 9447 9448 9449 // $ANTLR start "inclusiveOrExpression" 9450 // src/com/google/doclava/parser/Java.g:985:1: inclusiveOrExpression : exclusiveOrExpression ( '|' exclusiveOrExpression )* ; inclusiveOrExpression()9451 public final void inclusiveOrExpression() throws RecognitionException { 9452 int inclusiveOrExpression_StartIndex = input.index(); 9453 try { dbg.enterRule(getGrammarFileName(), "inclusiveOrExpression"); 9454 if ( getRuleLevel()==0 ) {dbg.commence();} 9455 incRuleLevel(); 9456 dbg.location(985, 1); 9457 9458 try { 9459 if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; } 9460 // src/com/google/doclava/parser/Java.g:986:5: ( exclusiveOrExpression ( '|' exclusiveOrExpression )* ) 9461 dbg.enterAlt(1); 9462 9463 // src/com/google/doclava/parser/Java.g:986:9: exclusiveOrExpression ( '|' exclusiveOrExpression )* 9464 { 9465 dbg.location(986,9); 9466 pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382); 9467 exclusiveOrExpression(); 9468 9469 state._fsp--; 9470 if (state.failed) return ; 9471 dbg.location(987,9); 9472 // src/com/google/doclava/parser/Java.g:987:9: ( '|' exclusiveOrExpression )* 9473 try { dbg.enterSubRule(116); 9474 9475 loop116: 9476 do { 9477 int alt116=2; 9478 try { dbg.enterDecision(116, decisionCanBacktrack[116]); 9479 9480 int LA116_0 = input.LA(1); 9481 9482 if ( (LA116_0==BAR) ) { 9483 alt116=1; 9484 } 9485 9486 9487 } finally {dbg.exitDecision(116);} 9488 9489 switch (alt116) { 9490 case 1 : 9491 dbg.enterAlt(1); 9492 9493 // src/com/google/doclava/parser/Java.g:987:10: '|' exclusiveOrExpression 9494 { 9495 dbg.location(987,10); 9496 match(input,BAR,FOLLOW_BAR_in_inclusiveOrExpression5393); if (state.failed) return ; 9497 dbg.location(987,14); 9498 pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395); 9499 exclusiveOrExpression(); 9500 9501 state._fsp--; 9502 if (state.failed) return ; 9503 9504 } 9505 break; 9506 9507 default : 9508 break loop116; 9509 } 9510 } while (true); 9511 } finally {dbg.exitSubRule(116);} 9512 9513 9514 } 9515 9516 } 9517 catch (RecognitionException re) { 9518 reportError(re); 9519 recover(input,re); 9520 } 9521 finally { 9522 if ( state.backtracking>0 ) { memoize(input, 75, inclusiveOrExpression_StartIndex); } 9523 } 9524 dbg.location(989, 5); 9525 9526 } 9527 finally { 9528 dbg.exitRule(getGrammarFileName(), "inclusiveOrExpression"); 9529 decRuleLevel(); 9530 if ( getRuleLevel()==0 ) {dbg.terminate();} 9531 } 9532 9533 return ; 9534 } 9535 // $ANTLR end "inclusiveOrExpression" 9536 9537 9538 // $ANTLR start "exclusiveOrExpression" 9539 // src/com/google/doclava/parser/Java.g:991:1: exclusiveOrExpression : andExpression ( '^' andExpression )* ; exclusiveOrExpression()9540 public final void exclusiveOrExpression() throws RecognitionException { 9541 int exclusiveOrExpression_StartIndex = input.index(); 9542 try { dbg.enterRule(getGrammarFileName(), "exclusiveOrExpression"); 9543 if ( getRuleLevel()==0 ) {dbg.commence();} 9544 incRuleLevel(); 9545 dbg.location(991, 1); 9546 9547 try { 9548 if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; } 9549 // src/com/google/doclava/parser/Java.g:992:5: ( andExpression ( '^' andExpression )* ) 9550 dbg.enterAlt(1); 9551 9552 // src/com/google/doclava/parser/Java.g:992:9: andExpression ( '^' andExpression )* 9553 { 9554 dbg.location(992,9); 9555 pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5425); 9556 andExpression(); 9557 9558 state._fsp--; 9559 if (state.failed) return ; 9560 dbg.location(993,9); 9561 // src/com/google/doclava/parser/Java.g:993:9: ( '^' andExpression )* 9562 try { dbg.enterSubRule(117); 9563 9564 loop117: 9565 do { 9566 int alt117=2; 9567 try { dbg.enterDecision(117, decisionCanBacktrack[117]); 9568 9569 int LA117_0 = input.LA(1); 9570 9571 if ( (LA117_0==CARET) ) { 9572 alt117=1; 9573 } 9574 9575 9576 } finally {dbg.exitDecision(117);} 9577 9578 switch (alt117) { 9579 case 1 : 9580 dbg.enterAlt(1); 9581 9582 // src/com/google/doclava/parser/Java.g:993:10: '^' andExpression 9583 { 9584 dbg.location(993,10); 9585 match(input,CARET,FOLLOW_CARET_in_exclusiveOrExpression5436); if (state.failed) return ; 9586 dbg.location(993,14); 9587 pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5438); 9588 andExpression(); 9589 9590 state._fsp--; 9591 if (state.failed) return ; 9592 9593 } 9594 break; 9595 9596 default : 9597 break loop117; 9598 } 9599 } while (true); 9600 } finally {dbg.exitSubRule(117);} 9601 9602 9603 } 9604 9605 } 9606 catch (RecognitionException re) { 9607 reportError(re); 9608 recover(input,re); 9609 } 9610 finally { 9611 if ( state.backtracking>0 ) { memoize(input, 76, exclusiveOrExpression_StartIndex); } 9612 } 9613 dbg.location(995, 5); 9614 9615 } 9616 finally { 9617 dbg.exitRule(getGrammarFileName(), "exclusiveOrExpression"); 9618 decRuleLevel(); 9619 if ( getRuleLevel()==0 ) {dbg.terminate();} 9620 } 9621 9622 return ; 9623 } 9624 // $ANTLR end "exclusiveOrExpression" 9625 9626 9627 // $ANTLR start "andExpression" 9628 // src/com/google/doclava/parser/Java.g:997:1: andExpression : equalityExpression ( '&' equalityExpression )* ; andExpression()9629 public final void andExpression() throws RecognitionException { 9630 int andExpression_StartIndex = input.index(); 9631 try { dbg.enterRule(getGrammarFileName(), "andExpression"); 9632 if ( getRuleLevel()==0 ) {dbg.commence();} 9633 incRuleLevel(); 9634 dbg.location(997, 1); 9635 9636 try { 9637 if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; } 9638 // src/com/google/doclava/parser/Java.g:998:5: ( equalityExpression ( '&' equalityExpression )* ) 9639 dbg.enterAlt(1); 9640 9641 // src/com/google/doclava/parser/Java.g:998:9: equalityExpression ( '&' equalityExpression )* 9642 { 9643 dbg.location(998,9); 9644 pushFollow(FOLLOW_equalityExpression_in_andExpression5468); 9645 equalityExpression(); 9646 9647 state._fsp--; 9648 if (state.failed) return ; 9649 dbg.location(999,9); 9650 // src/com/google/doclava/parser/Java.g:999:9: ( '&' equalityExpression )* 9651 try { dbg.enterSubRule(118); 9652 9653 loop118: 9654 do { 9655 int alt118=2; 9656 try { dbg.enterDecision(118, decisionCanBacktrack[118]); 9657 9658 int LA118_0 = input.LA(1); 9659 9660 if ( (LA118_0==AMP) ) { 9661 alt118=1; 9662 } 9663 9664 9665 } finally {dbg.exitDecision(118);} 9666 9667 switch (alt118) { 9668 case 1 : 9669 dbg.enterAlt(1); 9670 9671 // src/com/google/doclava/parser/Java.g:999:10: '&' equalityExpression 9672 { 9673 dbg.location(999,10); 9674 match(input,AMP,FOLLOW_AMP_in_andExpression5479); if (state.failed) return ; 9675 dbg.location(999,14); 9676 pushFollow(FOLLOW_equalityExpression_in_andExpression5481); 9677 equalityExpression(); 9678 9679 state._fsp--; 9680 if (state.failed) return ; 9681 9682 } 9683 break; 9684 9685 default : 9686 break loop118; 9687 } 9688 } while (true); 9689 } finally {dbg.exitSubRule(118);} 9690 9691 9692 } 9693 9694 } 9695 catch (RecognitionException re) { 9696 reportError(re); 9697 recover(input,re); 9698 } 9699 finally { 9700 if ( state.backtracking>0 ) { memoize(input, 77, andExpression_StartIndex); } 9701 } 9702 dbg.location(1001, 5); 9703 9704 } 9705 finally { 9706 dbg.exitRule(getGrammarFileName(), "andExpression"); 9707 decRuleLevel(); 9708 if ( getRuleLevel()==0 ) {dbg.terminate();} 9709 } 9710 9711 return ; 9712 } 9713 // $ANTLR end "andExpression" 9714 9715 9716 // $ANTLR start "equalityExpression" 9717 // src/com/google/doclava/parser/Java.g:1003:1: equalityExpression : instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ; equalityExpression()9718 public final void equalityExpression() throws RecognitionException { 9719 int equalityExpression_StartIndex = input.index(); 9720 try { dbg.enterRule(getGrammarFileName(), "equalityExpression"); 9721 if ( getRuleLevel()==0 ) {dbg.commence();} 9722 incRuleLevel(); 9723 dbg.location(1003, 1); 9724 9725 try { 9726 if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; } 9727 // src/com/google/doclava/parser/Java.g:1004:5: ( instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ) 9728 dbg.enterAlt(1); 9729 9730 // src/com/google/doclava/parser/Java.g:1004:9: instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* 9731 { 9732 dbg.location(1004,9); 9733 pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5511); 9734 instanceOfExpression(); 9735 9736 state._fsp--; 9737 if (state.failed) return ; 9738 dbg.location(1005,9); 9739 // src/com/google/doclava/parser/Java.g:1005:9: ( ( '==' | '!=' ) instanceOfExpression )* 9740 try { dbg.enterSubRule(119); 9741 9742 loop119: 9743 do { 9744 int alt119=2; 9745 try { dbg.enterDecision(119, decisionCanBacktrack[119]); 9746 9747 int LA119_0 = input.LA(1); 9748 9749 if ( (LA119_0==EQEQ||LA119_0==BANGEQ) ) { 9750 alt119=1; 9751 } 9752 9753 9754 } finally {dbg.exitDecision(119);} 9755 9756 switch (alt119) { 9757 case 1 : 9758 dbg.enterAlt(1); 9759 9760 // src/com/google/doclava/parser/Java.g:1006:13: ( '==' | '!=' ) instanceOfExpression 9761 { 9762 dbg.location(1006,13); 9763 if ( input.LA(1)==EQEQ||input.LA(1)==BANGEQ ) { 9764 input.consume(); 9765 state.errorRecovery=false;state.failed=false; 9766 } 9767 else { 9768 if (state.backtracking>0) {state.failed=true; return ;} 9769 MismatchedSetException mse = new MismatchedSetException(null,input); 9770 dbg.recognitionException(mse); 9771 throw mse; 9772 } 9773 9774 dbg.location(1009,13); 9775 pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5585); 9776 instanceOfExpression(); 9777 9778 state._fsp--; 9779 if (state.failed) return ; 9780 9781 } 9782 break; 9783 9784 default : 9785 break loop119; 9786 } 9787 } while (true); 9788 } finally {dbg.exitSubRule(119);} 9789 9790 9791 } 9792 9793 } 9794 catch (RecognitionException re) { 9795 reportError(re); 9796 recover(input,re); 9797 } 9798 finally { 9799 if ( state.backtracking>0 ) { memoize(input, 78, equalityExpression_StartIndex); } 9800 } 9801 dbg.location(1011, 5); 9802 9803 } 9804 finally { 9805 dbg.exitRule(getGrammarFileName(), "equalityExpression"); 9806 decRuleLevel(); 9807 if ( getRuleLevel()==0 ) {dbg.terminate();} 9808 } 9809 9810 return ; 9811 } 9812 // $ANTLR end "equalityExpression" 9813 9814 9815 // $ANTLR start "instanceOfExpression" 9816 // src/com/google/doclava/parser/Java.g:1013:1: instanceOfExpression : relationalExpression ( 'instanceof' type )? ; instanceOfExpression()9817 public final void instanceOfExpression() throws RecognitionException { 9818 int instanceOfExpression_StartIndex = input.index(); 9819 try { dbg.enterRule(getGrammarFileName(), "instanceOfExpression"); 9820 if ( getRuleLevel()==0 ) {dbg.commence();} 9821 incRuleLevel(); 9822 dbg.location(1013, 1); 9823 9824 try { 9825 if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; } 9826 // src/com/google/doclava/parser/Java.g:1014:5: ( relationalExpression ( 'instanceof' type )? ) 9827 dbg.enterAlt(1); 9828 9829 // src/com/google/doclava/parser/Java.g:1014:9: relationalExpression ( 'instanceof' type )? 9830 { 9831 dbg.location(1014,9); 9832 pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression5615); 9833 relationalExpression(); 9834 9835 state._fsp--; 9836 if (state.failed) return ; 9837 dbg.location(1015,9); 9838 // src/com/google/doclava/parser/Java.g:1015:9: ( 'instanceof' type )? 9839 int alt120=2; 9840 try { dbg.enterSubRule(120); 9841 try { dbg.enterDecision(120, decisionCanBacktrack[120]); 9842 9843 int LA120_0 = input.LA(1); 9844 9845 if ( (LA120_0==INSTANCEOF) ) { 9846 alt120=1; 9847 } 9848 } finally {dbg.exitDecision(120);} 9849 9850 switch (alt120) { 9851 case 1 : 9852 dbg.enterAlt(1); 9853 9854 // src/com/google/doclava/parser/Java.g:1015:10: 'instanceof' type 9855 { 9856 dbg.location(1015,10); 9857 match(input,INSTANCEOF,FOLLOW_INSTANCEOF_in_instanceOfExpression5626); if (state.failed) return ; 9858 dbg.location(1015,23); 9859 pushFollow(FOLLOW_type_in_instanceOfExpression5628); 9860 type(); 9861 9862 state._fsp--; 9863 if (state.failed) return ; 9864 9865 } 9866 break; 9867 9868 } 9869 } finally {dbg.exitSubRule(120);} 9870 9871 9872 } 9873 9874 } 9875 catch (RecognitionException re) { 9876 reportError(re); 9877 recover(input,re); 9878 } 9879 finally { 9880 if ( state.backtracking>0 ) { memoize(input, 79, instanceOfExpression_StartIndex); } 9881 } 9882 dbg.location(1017, 5); 9883 9884 } 9885 finally { 9886 dbg.exitRule(getGrammarFileName(), "instanceOfExpression"); 9887 decRuleLevel(); 9888 if ( getRuleLevel()==0 ) {dbg.terminate();} 9889 } 9890 9891 return ; 9892 } 9893 // $ANTLR end "instanceOfExpression" 9894 9895 9896 // $ANTLR start "relationalExpression" 9897 // src/com/google/doclava/parser/Java.g:1019:1: relationalExpression : shiftExpression ( relationalOp shiftExpression )* ; relationalExpression()9898 public final void relationalExpression() throws RecognitionException { 9899 int relationalExpression_StartIndex = input.index(); 9900 try { dbg.enterRule(getGrammarFileName(), "relationalExpression"); 9901 if ( getRuleLevel()==0 ) {dbg.commence();} 9902 incRuleLevel(); 9903 dbg.location(1019, 1); 9904 9905 try { 9906 if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; } 9907 // src/com/google/doclava/parser/Java.g:1020:5: ( shiftExpression ( relationalOp shiftExpression )* ) 9908 dbg.enterAlt(1); 9909 9910 // src/com/google/doclava/parser/Java.g:1020:9: shiftExpression ( relationalOp shiftExpression )* 9911 { 9912 dbg.location(1020,9); 9913 pushFollow(FOLLOW_shiftExpression_in_relationalExpression5658); 9914 shiftExpression(); 9915 9916 state._fsp--; 9917 if (state.failed) return ; 9918 dbg.location(1021,9); 9919 // src/com/google/doclava/parser/Java.g:1021:9: ( relationalOp shiftExpression )* 9920 try { dbg.enterSubRule(121); 9921 9922 loop121: 9923 do { 9924 int alt121=2; 9925 try { dbg.enterDecision(121, decisionCanBacktrack[121]); 9926 9927 int LA121_0 = input.LA(1); 9928 9929 if ( (LA121_0==LT) ) { 9930 int LA121_2 = input.LA(2); 9931 9932 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)) ) { 9933 alt121=1; 9934 } 9935 9936 9937 } 9938 else if ( (LA121_0==GT) ) { 9939 int LA121_3 = input.LA(2); 9940 9941 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)) ) { 9942 alt121=1; 9943 } 9944 9945 9946 } 9947 9948 9949 } finally {dbg.exitDecision(121);} 9950 9951 switch (alt121) { 9952 case 1 : 9953 dbg.enterAlt(1); 9954 9955 // src/com/google/doclava/parser/Java.g:1021:10: relationalOp shiftExpression 9956 { 9957 dbg.location(1021,10); 9958 pushFollow(FOLLOW_relationalOp_in_relationalExpression5669); 9959 relationalOp(); 9960 9961 state._fsp--; 9962 if (state.failed) return ; 9963 dbg.location(1021,23); 9964 pushFollow(FOLLOW_shiftExpression_in_relationalExpression5671); 9965 shiftExpression(); 9966 9967 state._fsp--; 9968 if (state.failed) return ; 9969 9970 } 9971 break; 9972 9973 default : 9974 break loop121; 9975 } 9976 } while (true); 9977 } finally {dbg.exitSubRule(121);} 9978 9979 9980 } 9981 9982 } 9983 catch (RecognitionException re) { 9984 reportError(re); 9985 recover(input,re); 9986 } 9987 finally { 9988 if ( state.backtracking>0 ) { memoize(input, 80, relationalExpression_StartIndex); } 9989 } 9990 dbg.location(1023, 5); 9991 9992 } 9993 finally { 9994 dbg.exitRule(getGrammarFileName(), "relationalExpression"); 9995 decRuleLevel(); 9996 if ( getRuleLevel()==0 ) {dbg.terminate();} 9997 } 9998 9999 return ; 10000 } 10001 // $ANTLR end "relationalExpression" 10002 10003 10004 // $ANTLR start "relationalOp" 10005 // src/com/google/doclava/parser/Java.g:1025:1: relationalOp : ( '<' '=' | '>' '=' | '<' | '>' ); relationalOp()10006 public final void relationalOp() throws RecognitionException { 10007 int relationalOp_StartIndex = input.index(); 10008 try { dbg.enterRule(getGrammarFileName(), "relationalOp"); 10009 if ( getRuleLevel()==0 ) {dbg.commence();} 10010 incRuleLevel(); 10011 dbg.location(1025, 1); 10012 10013 try { 10014 if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; } 10015 // src/com/google/doclava/parser/Java.g:1026:5: ( '<' '=' | '>' '=' | '<' | '>' ) 10016 int alt122=4; 10017 try { dbg.enterDecision(122, decisionCanBacktrack[122]); 10018 10019 int LA122_0 = input.LA(1); 10020 10021 if ( (LA122_0==LT) ) { 10022 int LA122_1 = input.LA(2); 10023 10024 if ( (LA122_1==EQ) ) { 10025 alt122=1; 10026 } 10027 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)) ) { 10028 alt122=3; 10029 } 10030 else { 10031 if (state.backtracking>0) {state.failed=true; return ;} 10032 NoViableAltException nvae = 10033 new NoViableAltException("", 122, 1, input); 10034 10035 dbg.recognitionException(nvae); 10036 throw nvae; 10037 } 10038 } 10039 else if ( (LA122_0==GT) ) { 10040 int LA122_2 = input.LA(2); 10041 10042 if ( (LA122_2==EQ) ) { 10043 alt122=2; 10044 } 10045 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)) ) { 10046 alt122=4; 10047 } 10048 else { 10049 if (state.backtracking>0) {state.failed=true; return ;} 10050 NoViableAltException nvae = 10051 new NoViableAltException("", 122, 2, input); 10052 10053 dbg.recognitionException(nvae); 10054 throw nvae; 10055 } 10056 } 10057 else { 10058 if (state.backtracking>0) {state.failed=true; return ;} 10059 NoViableAltException nvae = 10060 new NoViableAltException("", 122, 0, input); 10061 10062 dbg.recognitionException(nvae); 10063 throw nvae; 10064 } 10065 } finally {dbg.exitDecision(122);} 10066 10067 switch (alt122) { 10068 case 1 : 10069 dbg.enterAlt(1); 10070 10071 // src/com/google/doclava/parser/Java.g:1026:10: '<' '=' 10072 { 10073 dbg.location(1026,10); 10074 match(input,LT,FOLLOW_LT_in_relationalOp5702); if (state.failed) return ; 10075 dbg.location(1026,14); 10076 match(input,EQ,FOLLOW_EQ_in_relationalOp5704); if (state.failed) return ; 10077 10078 } 10079 break; 10080 case 2 : 10081 dbg.enterAlt(2); 10082 10083 // src/com/google/doclava/parser/Java.g:1027:10: '>' '=' 10084 { 10085 dbg.location(1027,10); 10086 match(input,GT,FOLLOW_GT_in_relationalOp5715); if (state.failed) return ; 10087 dbg.location(1027,14); 10088 match(input,EQ,FOLLOW_EQ_in_relationalOp5717); if (state.failed) return ; 10089 10090 } 10091 break; 10092 case 3 : 10093 dbg.enterAlt(3); 10094 10095 // src/com/google/doclava/parser/Java.g:1028:9: '<' 10096 { 10097 dbg.location(1028,9); 10098 match(input,LT,FOLLOW_LT_in_relationalOp5727); if (state.failed) return ; 10099 10100 } 10101 break; 10102 case 4 : 10103 dbg.enterAlt(4); 10104 10105 // src/com/google/doclava/parser/Java.g:1029:9: '>' 10106 { 10107 dbg.location(1029,9); 10108 match(input,GT,FOLLOW_GT_in_relationalOp5737); if (state.failed) return ; 10109 10110 } 10111 break; 10112 10113 } 10114 } 10115 catch (RecognitionException re) { 10116 reportError(re); 10117 recover(input,re); 10118 } 10119 finally { 10120 if ( state.backtracking>0 ) { memoize(input, 81, relationalOp_StartIndex); } 10121 } 10122 dbg.location(1030, 5); 10123 10124 } 10125 finally { 10126 dbg.exitRule(getGrammarFileName(), "relationalOp"); 10127 decRuleLevel(); 10128 if ( getRuleLevel()==0 ) {dbg.terminate();} 10129 } 10130 10131 return ; 10132 } 10133 // $ANTLR end "relationalOp" 10134 10135 10136 // $ANTLR start "shiftExpression" 10137 // src/com/google/doclava/parser/Java.g:1032:1: shiftExpression : additiveExpression ( shiftOp additiveExpression )* ; shiftExpression()10138 public final void shiftExpression() throws RecognitionException { 10139 int shiftExpression_StartIndex = input.index(); 10140 try { dbg.enterRule(getGrammarFileName(), "shiftExpression"); 10141 if ( getRuleLevel()==0 ) {dbg.commence();} 10142 incRuleLevel(); 10143 dbg.location(1032, 1); 10144 10145 try { 10146 if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; } 10147 // src/com/google/doclava/parser/Java.g:1033:5: ( additiveExpression ( shiftOp additiveExpression )* ) 10148 dbg.enterAlt(1); 10149 10150 // src/com/google/doclava/parser/Java.g:1033:9: additiveExpression ( shiftOp additiveExpression )* 10151 { 10152 dbg.location(1033,9); 10153 pushFollow(FOLLOW_additiveExpression_in_shiftExpression5756); 10154 additiveExpression(); 10155 10156 state._fsp--; 10157 if (state.failed) return ; 10158 dbg.location(1034,9); 10159 // src/com/google/doclava/parser/Java.g:1034:9: ( shiftOp additiveExpression )* 10160 try { dbg.enterSubRule(123); 10161 10162 loop123: 10163 do { 10164 int alt123=2; 10165 try { dbg.enterDecision(123, decisionCanBacktrack[123]); 10166 10167 int LA123_0 = input.LA(1); 10168 10169 if ( (LA123_0==LT) ) { 10170 int LA123_1 = input.LA(2); 10171 10172 if ( (LA123_1==LT) ) { 10173 int LA123_4 = input.LA(3); 10174 10175 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)) ) { 10176 alt123=1; 10177 } 10178 10179 10180 } 10181 10182 10183 } 10184 else if ( (LA123_0==GT) ) { 10185 int LA123_2 = input.LA(2); 10186 10187 if ( (LA123_2==GT) ) { 10188 int LA123_5 = input.LA(3); 10189 10190 if ( (LA123_5==GT) ) { 10191 int LA123_7 = input.LA(4); 10192 10193 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)) ) { 10194 alt123=1; 10195 } 10196 10197 10198 } 10199 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)) ) { 10200 alt123=1; 10201 } 10202 10203 10204 } 10205 10206 10207 } 10208 10209 10210 } finally {dbg.exitDecision(123);} 10211 10212 switch (alt123) { 10213 case 1 : 10214 dbg.enterAlt(1); 10215 10216 // src/com/google/doclava/parser/Java.g:1034:10: shiftOp additiveExpression 10217 { 10218 dbg.location(1034,10); 10219 pushFollow(FOLLOW_shiftOp_in_shiftExpression5767); 10220 shiftOp(); 10221 10222 state._fsp--; 10223 if (state.failed) return ; 10224 dbg.location(1034,18); 10225 pushFollow(FOLLOW_additiveExpression_in_shiftExpression5769); 10226 additiveExpression(); 10227 10228 state._fsp--; 10229 if (state.failed) return ; 10230 10231 } 10232 break; 10233 10234 default : 10235 break loop123; 10236 } 10237 } while (true); 10238 } finally {dbg.exitSubRule(123);} 10239 10240 10241 } 10242 10243 } 10244 catch (RecognitionException re) { 10245 reportError(re); 10246 recover(input,re); 10247 } 10248 finally { 10249 if ( state.backtracking>0 ) { memoize(input, 82, shiftExpression_StartIndex); } 10250 } 10251 dbg.location(1036, 5); 10252 10253 } 10254 finally { 10255 dbg.exitRule(getGrammarFileName(), "shiftExpression"); 10256 decRuleLevel(); 10257 if ( getRuleLevel()==0 ) {dbg.terminate();} 10258 } 10259 10260 return ; 10261 } 10262 // $ANTLR end "shiftExpression" 10263 10264 10265 // $ANTLR start "shiftOp" 10266 // src/com/google/doclava/parser/Java.g:1039:1: shiftOp : ( '<' '<' | '>' '>' '>' | '>' '>' ); shiftOp()10267 public final void shiftOp() throws RecognitionException { 10268 int shiftOp_StartIndex = input.index(); 10269 try { dbg.enterRule(getGrammarFileName(), "shiftOp"); 10270 if ( getRuleLevel()==0 ) {dbg.commence();} 10271 incRuleLevel(); 10272 dbg.location(1039, 1); 10273 10274 try { 10275 if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; } 10276 // src/com/google/doclava/parser/Java.g:1040:5: ( '<' '<' | '>' '>' '>' | '>' '>' ) 10277 int alt124=3; 10278 try { dbg.enterDecision(124, decisionCanBacktrack[124]); 10279 10280 int LA124_0 = input.LA(1); 10281 10282 if ( (LA124_0==LT) ) { 10283 alt124=1; 10284 } 10285 else if ( (LA124_0==GT) ) { 10286 int LA124_2 = input.LA(2); 10287 10288 if ( (LA124_2==GT) ) { 10289 int LA124_3 = input.LA(3); 10290 10291 if ( (LA124_3==GT) ) { 10292 alt124=2; 10293 } 10294 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)) ) { 10295 alt124=3; 10296 } 10297 else { 10298 if (state.backtracking>0) {state.failed=true; return ;} 10299 NoViableAltException nvae = 10300 new NoViableAltException("", 124, 3, input); 10301 10302 dbg.recognitionException(nvae); 10303 throw nvae; 10304 } 10305 } 10306 else { 10307 if (state.backtracking>0) {state.failed=true; return ;} 10308 NoViableAltException nvae = 10309 new NoViableAltException("", 124, 2, input); 10310 10311 dbg.recognitionException(nvae); 10312 throw nvae; 10313 } 10314 } 10315 else { 10316 if (state.backtracking>0) {state.failed=true; return ;} 10317 NoViableAltException nvae = 10318 new NoViableAltException("", 124, 0, input); 10319 10320 dbg.recognitionException(nvae); 10321 throw nvae; 10322 } 10323 } finally {dbg.exitDecision(124);} 10324 10325 switch (alt124) { 10326 case 1 : 10327 dbg.enterAlt(1); 10328 10329 // src/com/google/doclava/parser/Java.g:1040:10: '<' '<' 10330 { 10331 dbg.location(1040,10); 10332 match(input,LT,FOLLOW_LT_in_shiftOp5801); if (state.failed) return ; 10333 dbg.location(1040,14); 10334 match(input,LT,FOLLOW_LT_in_shiftOp5803); if (state.failed) return ; 10335 10336 } 10337 break; 10338 case 2 : 10339 dbg.enterAlt(2); 10340 10341 // src/com/google/doclava/parser/Java.g:1041:10: '>' '>' '>' 10342 { 10343 dbg.location(1041,10); 10344 match(input,GT,FOLLOW_GT_in_shiftOp5814); if (state.failed) return ; 10345 dbg.location(1041,14); 10346 match(input,GT,FOLLOW_GT_in_shiftOp5816); if (state.failed) return ; 10347 dbg.location(1041,18); 10348 match(input,GT,FOLLOW_GT_in_shiftOp5818); if (state.failed) return ; 10349 10350 } 10351 break; 10352 case 3 : 10353 dbg.enterAlt(3); 10354 10355 // src/com/google/doclava/parser/Java.g:1042:10: '>' '>' 10356 { 10357 dbg.location(1042,10); 10358 match(input,GT,FOLLOW_GT_in_shiftOp5829); if (state.failed) return ; 10359 dbg.location(1042,14); 10360 match(input,GT,FOLLOW_GT_in_shiftOp5831); if (state.failed) return ; 10361 10362 } 10363 break; 10364 10365 } 10366 } 10367 catch (RecognitionException re) { 10368 reportError(re); 10369 recover(input,re); 10370 } 10371 finally { 10372 if ( state.backtracking>0 ) { memoize(input, 83, shiftOp_StartIndex); } 10373 } 10374 dbg.location(1043, 5); 10375 10376 } 10377 finally { 10378 dbg.exitRule(getGrammarFileName(), "shiftOp"); 10379 decRuleLevel(); 10380 if ( getRuleLevel()==0 ) {dbg.terminate();} 10381 } 10382 10383 return ; 10384 } 10385 // $ANTLR end "shiftOp" 10386 10387 10388 // $ANTLR start "additiveExpression" 10389 // src/com/google/doclava/parser/Java.g:1046:1: additiveExpression : multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ; additiveExpression()10390 public final void additiveExpression() throws RecognitionException { 10391 int additiveExpression_StartIndex = input.index(); 10392 try { dbg.enterRule(getGrammarFileName(), "additiveExpression"); 10393 if ( getRuleLevel()==0 ) {dbg.commence();} 10394 incRuleLevel(); 10395 dbg.location(1046, 1); 10396 10397 try { 10398 if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; } 10399 // src/com/google/doclava/parser/Java.g:1047:5: ( multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ) 10400 dbg.enterAlt(1); 10401 10402 // src/com/google/doclava/parser/Java.g:1047:9: multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* 10403 { 10404 dbg.location(1047,9); 10405 pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5851); 10406 multiplicativeExpression(); 10407 10408 state._fsp--; 10409 if (state.failed) return ; 10410 dbg.location(1048,9); 10411 // src/com/google/doclava/parser/Java.g:1048:9: ( ( '+' | '-' ) multiplicativeExpression )* 10412 try { dbg.enterSubRule(125); 10413 10414 loop125: 10415 do { 10416 int alt125=2; 10417 try { dbg.enterDecision(125, decisionCanBacktrack[125]); 10418 10419 int LA125_0 = input.LA(1); 10420 10421 if ( ((LA125_0>=PLUS && LA125_0<=SUB)) ) { 10422 alt125=1; 10423 } 10424 10425 10426 } finally {dbg.exitDecision(125);} 10427 10428 switch (alt125) { 10429 case 1 : 10430 dbg.enterAlt(1); 10431 10432 // src/com/google/doclava/parser/Java.g:1049:13: ( '+' | '-' ) multiplicativeExpression 10433 { 10434 dbg.location(1049,13); 10435 if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) { 10436 input.consume(); 10437 state.errorRecovery=false;state.failed=false; 10438 } 10439 else { 10440 if (state.backtracking>0) {state.failed=true; return ;} 10441 MismatchedSetException mse = new MismatchedSetException(null,input); 10442 dbg.recognitionException(mse); 10443 throw mse; 10444 } 10445 10446 dbg.location(1052,13); 10447 pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5925); 10448 multiplicativeExpression(); 10449 10450 state._fsp--; 10451 if (state.failed) return ; 10452 10453 } 10454 break; 10455 10456 default : 10457 break loop125; 10458 } 10459 } while (true); 10460 } finally {dbg.exitSubRule(125);} 10461 10462 10463 } 10464 10465 } 10466 catch (RecognitionException re) { 10467 reportError(re); 10468 recover(input,re); 10469 } 10470 finally { 10471 if ( state.backtracking>0 ) { memoize(input, 84, additiveExpression_StartIndex); } 10472 } 10473 dbg.location(1054, 5); 10474 10475 } 10476 finally { 10477 dbg.exitRule(getGrammarFileName(), "additiveExpression"); 10478 decRuleLevel(); 10479 if ( getRuleLevel()==0 ) {dbg.terminate();} 10480 } 10481 10482 return ; 10483 } 10484 // $ANTLR end "additiveExpression" 10485 10486 10487 // $ANTLR start "multiplicativeExpression" 10488 // src/com/google/doclava/parser/Java.g:1056:1: multiplicativeExpression : unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ; multiplicativeExpression()10489 public final void multiplicativeExpression() throws RecognitionException { 10490 int multiplicativeExpression_StartIndex = input.index(); 10491 try { dbg.enterRule(getGrammarFileName(), "multiplicativeExpression"); 10492 if ( getRuleLevel()==0 ) {dbg.commence();} 10493 incRuleLevel(); 10494 dbg.location(1056, 1); 10495 10496 try { 10497 if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; } 10498 // src/com/google/doclava/parser/Java.g:1057:5: ( unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ) 10499 dbg.enterAlt(1); 10500 10501 // src/com/google/doclava/parser/Java.g:1058:9: unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* 10502 { 10503 dbg.location(1058,9); 10504 pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5962); 10505 unaryExpression(); 10506 10507 state._fsp--; 10508 if (state.failed) return ; 10509 dbg.location(1059,9); 10510 // src/com/google/doclava/parser/Java.g:1059:9: ( ( '*' | '/' | '%' ) unaryExpression )* 10511 try { dbg.enterSubRule(126); 10512 10513 loop126: 10514 do { 10515 int alt126=2; 10516 try { dbg.enterDecision(126, decisionCanBacktrack[126]); 10517 10518 int LA126_0 = input.LA(1); 10519 10520 if ( ((LA126_0>=STAR && LA126_0<=SLASH)||LA126_0==PERCENT) ) { 10521 alt126=1; 10522 } 10523 10524 10525 } finally {dbg.exitDecision(126);} 10526 10527 switch (alt126) { 10528 case 1 : 10529 dbg.enterAlt(1); 10530 10531 // src/com/google/doclava/parser/Java.g:1060:13: ( '*' | '/' | '%' ) unaryExpression 10532 { 10533 dbg.location(1060,13); 10534 if ( (input.LA(1)>=STAR && input.LA(1)<=SLASH)||input.LA(1)==PERCENT ) { 10535 input.consume(); 10536 state.errorRecovery=false;state.failed=false; 10537 } 10538 else { 10539 if (state.backtracking>0) {state.failed=true; return ;} 10540 MismatchedSetException mse = new MismatchedSetException(null,input); 10541 dbg.recognitionException(mse); 10542 throw mse; 10543 } 10544 10545 dbg.location(1064,13); 10546 pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression6054); 10547 unaryExpression(); 10548 10549 state._fsp--; 10550 if (state.failed) return ; 10551 10552 } 10553 break; 10554 10555 default : 10556 break loop126; 10557 } 10558 } while (true); 10559 } finally {dbg.exitSubRule(126);} 10560 10561 10562 } 10563 10564 } 10565 catch (RecognitionException re) { 10566 reportError(re); 10567 recover(input,re); 10568 } 10569 finally { 10570 if ( state.backtracking>0 ) { memoize(input, 85, multiplicativeExpression_StartIndex); } 10571 } 10572 dbg.location(1066, 5); 10573 10574 } 10575 finally { 10576 dbg.exitRule(getGrammarFileName(), "multiplicativeExpression"); 10577 decRuleLevel(); 10578 if ( getRuleLevel()==0 ) {dbg.terminate();} 10579 } 10580 10581 return ; 10582 } 10583 // $ANTLR end "multiplicativeExpression" 10584 10585 10586 // $ANTLR start "unaryExpression" 10587 // src/com/google/doclava/parser/Java.g:1068:1: unaryExpression : ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus ); unaryExpression()10588 public final void unaryExpression() throws RecognitionException { 10589 int unaryExpression_StartIndex = input.index(); 10590 try { dbg.enterRule(getGrammarFileName(), "unaryExpression"); 10591 if ( getRuleLevel()==0 ) {dbg.commence();} 10592 incRuleLevel(); 10593 dbg.location(1068, 1); 10594 10595 try { 10596 if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; } 10597 // src/com/google/doclava/parser/Java.g:1073:5: ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus ) 10598 int alt127=5; 10599 try { dbg.enterDecision(127, decisionCanBacktrack[127]); 10600 10601 switch ( input.LA(1) ) { 10602 case PLUS: 10603 { 10604 alt127=1; 10605 } 10606 break; 10607 case SUB: 10608 { 10609 alt127=2; 10610 } 10611 break; 10612 case PLUSPLUS: 10613 { 10614 alt127=3; 10615 } 10616 break; 10617 case SUBSUB: 10618 { 10619 alt127=4; 10620 } 10621 break; 10622 case IDENTIFIER: 10623 case INTLITERAL: 10624 case LONGLITERAL: 10625 case FLOATLITERAL: 10626 case DOUBLELITERAL: 10627 case CHARLITERAL: 10628 case STRINGLITERAL: 10629 case TRUE: 10630 case FALSE: 10631 case NULL: 10632 case BOOLEAN: 10633 case BYTE: 10634 case CHAR: 10635 case DOUBLE: 10636 case FLOAT: 10637 case INT: 10638 case LONG: 10639 case NEW: 10640 case SHORT: 10641 case SUPER: 10642 case THIS: 10643 case VOID: 10644 case LPAREN: 10645 case BANG: 10646 case TILDE: 10647 { 10648 alt127=5; 10649 } 10650 break; 10651 default: 10652 if (state.backtracking>0) {state.failed=true; return ;} 10653 NoViableAltException nvae = 10654 new NoViableAltException("", 127, 0, input); 10655 10656 dbg.recognitionException(nvae); 10657 throw nvae; 10658 } 10659 10660 } finally {dbg.exitDecision(127);} 10661 10662 switch (alt127) { 10663 case 1 : 10664 dbg.enterAlt(1); 10665 10666 // src/com/google/doclava/parser/Java.g:1073:9: '+' unaryExpression 10667 { 10668 dbg.location(1073,9); 10669 match(input,PLUS,FOLLOW_PLUS_in_unaryExpression6086); if (state.failed) return ; 10670 dbg.location(1073,14); 10671 pushFollow(FOLLOW_unaryExpression_in_unaryExpression6089); 10672 unaryExpression(); 10673 10674 state._fsp--; 10675 if (state.failed) return ; 10676 10677 } 10678 break; 10679 case 2 : 10680 dbg.enterAlt(2); 10681 10682 // src/com/google/doclava/parser/Java.g:1074:9: '-' unaryExpression 10683 { 10684 dbg.location(1074,9); 10685 match(input,SUB,FOLLOW_SUB_in_unaryExpression6099); if (state.failed) return ; 10686 dbg.location(1074,13); 10687 pushFollow(FOLLOW_unaryExpression_in_unaryExpression6101); 10688 unaryExpression(); 10689 10690 state._fsp--; 10691 if (state.failed) return ; 10692 10693 } 10694 break; 10695 case 3 : 10696 dbg.enterAlt(3); 10697 10698 // src/com/google/doclava/parser/Java.g:1075:9: '++' unaryExpression 10699 { 10700 dbg.location(1075,9); 10701 match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpression6111); if (state.failed) return ; 10702 dbg.location(1075,14); 10703 pushFollow(FOLLOW_unaryExpression_in_unaryExpression6113); 10704 unaryExpression(); 10705 10706 state._fsp--; 10707 if (state.failed) return ; 10708 10709 } 10710 break; 10711 case 4 : 10712 dbg.enterAlt(4); 10713 10714 // src/com/google/doclava/parser/Java.g:1076:9: '--' unaryExpression 10715 { 10716 dbg.location(1076,9); 10717 match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpression6123); if (state.failed) return ; 10718 dbg.location(1076,14); 10719 pushFollow(FOLLOW_unaryExpression_in_unaryExpression6125); 10720 unaryExpression(); 10721 10722 state._fsp--; 10723 if (state.failed) return ; 10724 10725 } 10726 break; 10727 case 5 : 10728 dbg.enterAlt(5); 10729 10730 // src/com/google/doclava/parser/Java.g:1077:9: unaryExpressionNotPlusMinus 10731 { 10732 dbg.location(1077,9); 10733 pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135); 10734 unaryExpressionNotPlusMinus(); 10735 10736 state._fsp--; 10737 if (state.failed) return ; 10738 10739 } 10740 break; 10741 10742 } 10743 } 10744 catch (RecognitionException re) { 10745 reportError(re); 10746 recover(input,re); 10747 } 10748 finally { 10749 if ( state.backtracking>0 ) { memoize(input, 86, unaryExpression_StartIndex); } 10750 } 10751 dbg.location(1078, 5); 10752 10753 } 10754 finally { 10755 dbg.exitRule(getGrammarFileName(), "unaryExpression"); 10756 decRuleLevel(); 10757 if ( getRuleLevel()==0 ) {dbg.terminate();} 10758 } 10759 10760 return ; 10761 } 10762 // $ANTLR end "unaryExpression" 10763 10764 10765 // $ANTLR start "unaryExpressionNotPlusMinus" 10766 // src/com/google/doclava/parser/Java.g:1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? ); unaryExpressionNotPlusMinus()10767 public final void unaryExpressionNotPlusMinus() throws RecognitionException { 10768 int unaryExpressionNotPlusMinus_StartIndex = input.index(); 10769 try { dbg.enterRule(getGrammarFileName(), "unaryExpressionNotPlusMinus"); 10770 if ( getRuleLevel()==0 ) {dbg.commence();} 10771 incRuleLevel(); 10772 dbg.location(1080, 1); 10773 10774 try { 10775 if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; } 10776 // src/com/google/doclava/parser/Java.g:1081:5: ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? ) 10777 int alt130=4; 10778 try { dbg.enterDecision(130, decisionCanBacktrack[130]); 10779 10780 try { 10781 isCyclicDecision = true; 10782 alt130 = dfa130.predict(input); 10783 } 10784 catch (NoViableAltException nvae) { 10785 dbg.recognitionException(nvae); 10786 throw nvae; 10787 } 10788 } finally {dbg.exitDecision(130);} 10789 10790 switch (alt130) { 10791 case 1 : 10792 dbg.enterAlt(1); 10793 10794 // src/com/google/doclava/parser/Java.g:1081:9: '~' unaryExpression 10795 { 10796 dbg.location(1081,9); 10797 match(input,TILDE,FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154); if (state.failed) return ; 10798 dbg.location(1081,13); 10799 pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156); 10800 unaryExpression(); 10801 10802 state._fsp--; 10803 if (state.failed) return ; 10804 10805 } 10806 break; 10807 case 2 : 10808 dbg.enterAlt(2); 10809 10810 // src/com/google/doclava/parser/Java.g:1082:9: '!' unaryExpression 10811 { 10812 dbg.location(1082,9); 10813 match(input,BANG,FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166); if (state.failed) return ; 10814 dbg.location(1082,13); 10815 pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168); 10816 unaryExpression(); 10817 10818 state._fsp--; 10819 if (state.failed) return ; 10820 10821 } 10822 break; 10823 case 3 : 10824 dbg.enterAlt(3); 10825 10826 // src/com/google/doclava/parser/Java.g:1083:9: castExpression 10827 { 10828 dbg.location(1083,9); 10829 pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178); 10830 castExpression(); 10831 10832 state._fsp--; 10833 if (state.failed) return ; 10834 10835 } 10836 break; 10837 case 4 : 10838 dbg.enterAlt(4); 10839 10840 // src/com/google/doclava/parser/Java.g:1084:9: primary ( selector )* ( '++' | '--' )? 10841 { 10842 dbg.location(1084,9); 10843 pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus6188); 10844 primary(); 10845 10846 state._fsp--; 10847 if (state.failed) return ; 10848 dbg.location(1085,9); 10849 // src/com/google/doclava/parser/Java.g:1085:9: ( selector )* 10850 try { dbg.enterSubRule(128); 10851 10852 loop128: 10853 do { 10854 int alt128=2; 10855 try { dbg.enterDecision(128, decisionCanBacktrack[128]); 10856 10857 int LA128_0 = input.LA(1); 10858 10859 if ( (LA128_0==LBRACKET||LA128_0==DOT) ) { 10860 alt128=1; 10861 } 10862 10863 10864 } finally {dbg.exitDecision(128);} 10865 10866 switch (alt128) { 10867 case 1 : 10868 dbg.enterAlt(1); 10869 10870 // src/com/google/doclava/parser/Java.g:1085:10: selector 10871 { 10872 dbg.location(1085,10); 10873 pushFollow(FOLLOW_selector_in_unaryExpressionNotPlusMinus6199); 10874 selector(); 10875 10876 state._fsp--; 10877 if (state.failed) return ; 10878 10879 } 10880 break; 10881 10882 default : 10883 break loop128; 10884 } 10885 } while (true); 10886 } finally {dbg.exitSubRule(128);} 10887 10888 dbg.location(1087,9); 10889 // src/com/google/doclava/parser/Java.g:1087:9: ( '++' | '--' )? 10890 int alt129=2; 10891 try { dbg.enterSubRule(129); 10892 try { dbg.enterDecision(129, decisionCanBacktrack[129]); 10893 10894 int LA129_0 = input.LA(1); 10895 10896 if ( ((LA129_0>=PLUSPLUS && LA129_0<=SUBSUB)) ) { 10897 alt129=1; 10898 } 10899 } finally {dbg.exitDecision(129);} 10900 10901 switch (alt129) { 10902 case 1 : 10903 dbg.enterAlt(1); 10904 10905 // src/com/google/doclava/parser/Java.g: 10906 { 10907 dbg.location(1087,9); 10908 if ( (input.LA(1)>=PLUSPLUS && input.LA(1)<=SUBSUB) ) { 10909 input.consume(); 10910 state.errorRecovery=false;state.failed=false; 10911 } 10912 else { 10913 if (state.backtracking>0) {state.failed=true; return ;} 10914 MismatchedSetException mse = new MismatchedSetException(null,input); 10915 dbg.recognitionException(mse); 10916 throw mse; 10917 } 10918 10919 10920 } 10921 break; 10922 10923 } 10924 } finally {dbg.exitSubRule(129);} 10925 10926 10927 } 10928 break; 10929 10930 } 10931 } 10932 catch (RecognitionException re) { 10933 reportError(re); 10934 recover(input,re); 10935 } 10936 finally { 10937 if ( state.backtracking>0 ) { memoize(input, 87, unaryExpressionNotPlusMinus_StartIndex); } 10938 } 10939 dbg.location(1090, 5); 10940 10941 } 10942 finally { 10943 dbg.exitRule(getGrammarFileName(), "unaryExpressionNotPlusMinus"); 10944 decRuleLevel(); 10945 if ( getRuleLevel()==0 ) {dbg.terminate();} 10946 } 10947 10948 return ; 10949 } 10950 // $ANTLR end "unaryExpressionNotPlusMinus" 10951 10952 10953 // $ANTLR start "castExpression" 10954 // src/com/google/doclava/parser/Java.g:1092:1: castExpression : ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus ); castExpression()10955 public final void castExpression() throws RecognitionException { 10956 int castExpression_StartIndex = input.index(); 10957 try { dbg.enterRule(getGrammarFileName(), "castExpression"); 10958 if ( getRuleLevel()==0 ) {dbg.commence();} 10959 incRuleLevel(); 10960 dbg.location(1092, 1); 10961 10962 try { 10963 if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; } 10964 // src/com/google/doclava/parser/Java.g:1093:5: ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus ) 10965 int alt131=2; 10966 try { dbg.enterDecision(131, decisionCanBacktrack[131]); 10967 10968 int LA131_0 = input.LA(1); 10969 10970 if ( (LA131_0==LPAREN) ) { 10971 int LA131_1 = input.LA(2); 10972 10973 if ( (synpred206_Java()) ) { 10974 alt131=1; 10975 } 10976 else if ( (true) ) { 10977 alt131=2; 10978 } 10979 else { 10980 if (state.backtracking>0) {state.failed=true; return ;} 10981 NoViableAltException nvae = 10982 new NoViableAltException("", 131, 1, input); 10983 10984 dbg.recognitionException(nvae); 10985 throw nvae; 10986 } 10987 } 10988 else { 10989 if (state.backtracking>0) {state.failed=true; return ;} 10990 NoViableAltException nvae = 10991 new NoViableAltException("", 131, 0, input); 10992 10993 dbg.recognitionException(nvae); 10994 throw nvae; 10995 } 10996 } finally {dbg.exitDecision(131);} 10997 10998 switch (alt131) { 10999 case 1 : 11000 dbg.enterAlt(1); 11001 11002 // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression 11003 { 11004 dbg.location(1093,9); 11005 match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6268); if (state.failed) return ; 11006 dbg.location(1093,13); 11007 pushFollow(FOLLOW_primitiveType_in_castExpression6270); 11008 primitiveType(); 11009 11010 state._fsp--; 11011 if (state.failed) return ; 11012 dbg.location(1093,27); 11013 match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6272); if (state.failed) return ; 11014 dbg.location(1093,31); 11015 pushFollow(FOLLOW_unaryExpression_in_castExpression6274); 11016 unaryExpression(); 11017 11018 state._fsp--; 11019 if (state.failed) return ; 11020 11021 } 11022 break; 11023 case 2 : 11024 dbg.enterAlt(2); 11025 11026 // src/com/google/doclava/parser/Java.g:1094:9: '(' type ')' unaryExpressionNotPlusMinus 11027 { 11028 dbg.location(1094,9); 11029 match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6284); if (state.failed) return ; 11030 dbg.location(1094,13); 11031 pushFollow(FOLLOW_type_in_castExpression6286); 11032 type(); 11033 11034 state._fsp--; 11035 if (state.failed) return ; 11036 dbg.location(1094,18); 11037 match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6288); if (state.failed) return ; 11038 dbg.location(1094,22); 11039 pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290); 11040 unaryExpressionNotPlusMinus(); 11041 11042 state._fsp--; 11043 if (state.failed) return ; 11044 11045 } 11046 break; 11047 11048 } 11049 } 11050 catch (RecognitionException re) { 11051 reportError(re); 11052 recover(input,re); 11053 } 11054 finally { 11055 if ( state.backtracking>0 ) { memoize(input, 88, castExpression_StartIndex); } 11056 } 11057 dbg.location(1095, 5); 11058 11059 } 11060 finally { 11061 dbg.exitRule(getGrammarFileName(), "castExpression"); 11062 decRuleLevel(); 11063 if ( getRuleLevel()==0 ) {dbg.terminate();} 11064 } 11065 11066 return ; 11067 } 11068 // $ANTLR end "castExpression" 11069 11070 11071 // $ANTLR start "primary" 11072 // 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' ); primary()11073 public final void primary() throws RecognitionException { 11074 int primary_StartIndex = input.index(); 11075 try { dbg.enterRule(getGrammarFileName(), "primary"); 11076 if ( getRuleLevel()==0 ) {dbg.commence();} 11077 incRuleLevel(); 11078 dbg.location(1097, 1); 11079 11080 try { 11081 if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; } 11082 // src/com/google/doclava/parser/Java.g:1101:5: ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' ) 11083 int alt137=8; 11084 try { dbg.enterDecision(137, decisionCanBacktrack[137]); 11085 11086 switch ( input.LA(1) ) { 11087 case LPAREN: 11088 { 11089 alt137=1; 11090 } 11091 break; 11092 case THIS: 11093 { 11094 alt137=2; 11095 } 11096 break; 11097 case IDENTIFIER: 11098 { 11099 alt137=3; 11100 } 11101 break; 11102 case SUPER: 11103 { 11104 alt137=4; 11105 } 11106 break; 11107 case INTLITERAL: 11108 case LONGLITERAL: 11109 case FLOATLITERAL: 11110 case DOUBLELITERAL: 11111 case CHARLITERAL: 11112 case STRINGLITERAL: 11113 case TRUE: 11114 case FALSE: 11115 case NULL: 11116 { 11117 alt137=5; 11118 } 11119 break; 11120 case NEW: 11121 { 11122 alt137=6; 11123 } 11124 break; 11125 case BOOLEAN: 11126 case BYTE: 11127 case CHAR: 11128 case DOUBLE: 11129 case FLOAT: 11130 case INT: 11131 case LONG: 11132 case SHORT: 11133 { 11134 alt137=7; 11135 } 11136 break; 11137 case VOID: 11138 { 11139 alt137=8; 11140 } 11141 break; 11142 default: 11143 if (state.backtracking>0) {state.failed=true; return ;} 11144 NoViableAltException nvae = 11145 new NoViableAltException("", 137, 0, input); 11146 11147 dbg.recognitionException(nvae); 11148 throw nvae; 11149 } 11150 11151 } finally {dbg.exitDecision(137);} 11152 11153 switch (alt137) { 11154 case 1 : 11155 dbg.enterAlt(1); 11156 11157 // src/com/google/doclava/parser/Java.g:1101:9: parExpression 11158 { 11159 dbg.location(1101,9); 11160 pushFollow(FOLLOW_parExpression_in_primary6311); 11161 parExpression(); 11162 11163 state._fsp--; 11164 if (state.failed) return ; 11165 11166 } 11167 break; 11168 case 2 : 11169 dbg.enterAlt(2); 11170 11171 // src/com/google/doclava/parser/Java.g:1102:9: 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? 11172 { 11173 dbg.location(1102,9); 11174 match(input,THIS,FOLLOW_THIS_in_primary6321); if (state.failed) return ; 11175 dbg.location(1103,9); 11176 // src/com/google/doclava/parser/Java.g:1103:9: ( '.' IDENTIFIER )* 11177 try { dbg.enterSubRule(132); 11178 11179 loop132: 11180 do { 11181 int alt132=2; 11182 try { dbg.enterDecision(132, decisionCanBacktrack[132]); 11183 11184 int LA132_0 = input.LA(1); 11185 11186 if ( (LA132_0==DOT) ) { 11187 int LA132_2 = input.LA(2); 11188 11189 if ( (LA132_2==IDENTIFIER) ) { 11190 int LA132_3 = input.LA(3); 11191 11192 if ( (synpred208_Java()) ) { 11193 alt132=1; 11194 } 11195 11196 11197 } 11198 11199 11200 } 11201 11202 11203 } finally {dbg.exitDecision(132);} 11204 11205 switch (alt132) { 11206 case 1 : 11207 dbg.enterAlt(1); 11208 11209 // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER 11210 { 11211 dbg.location(1103,10); 11212 match(input,DOT,FOLLOW_DOT_in_primary6332); if (state.failed) return ; 11213 dbg.location(1103,14); 11214 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6334); if (state.failed) return ; 11215 11216 } 11217 break; 11218 11219 default : 11220 break loop132; 11221 } 11222 } while (true); 11223 } finally {dbg.exitSubRule(132);} 11224 11225 dbg.location(1105,9); 11226 // src/com/google/doclava/parser/Java.g:1105:9: ( identifierSuffix )? 11227 int alt133=2; 11228 try { dbg.enterSubRule(133); 11229 try { dbg.enterDecision(133, decisionCanBacktrack[133]); 11230 11231 try { 11232 isCyclicDecision = true; 11233 alt133 = dfa133.predict(input); 11234 } 11235 catch (NoViableAltException nvae) { 11236 dbg.recognitionException(nvae); 11237 throw nvae; 11238 } 11239 } finally {dbg.exitDecision(133);} 11240 11241 switch (alt133) { 11242 case 1 : 11243 dbg.enterAlt(1); 11244 11245 // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix 11246 { 11247 dbg.location(1105,10); 11248 pushFollow(FOLLOW_identifierSuffix_in_primary6356); 11249 identifierSuffix(); 11250 11251 state._fsp--; 11252 if (state.failed) return ; 11253 11254 } 11255 break; 11256 11257 } 11258 } finally {dbg.exitSubRule(133);} 11259 11260 11261 } 11262 break; 11263 case 3 : 11264 dbg.enterAlt(3); 11265 11266 // src/com/google/doclava/parser/Java.g:1107:9: IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? 11267 { 11268 dbg.location(1107,9); 11269 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6377); if (state.failed) return ; 11270 dbg.location(1108,9); 11271 // src/com/google/doclava/parser/Java.g:1108:9: ( '.' IDENTIFIER )* 11272 try { dbg.enterSubRule(134); 11273 11274 loop134: 11275 do { 11276 int alt134=2; 11277 try { dbg.enterDecision(134, decisionCanBacktrack[134]); 11278 11279 int LA134_0 = input.LA(1); 11280 11281 if ( (LA134_0==DOT) ) { 11282 int LA134_2 = input.LA(2); 11283 11284 if ( (LA134_2==IDENTIFIER) ) { 11285 int LA134_3 = input.LA(3); 11286 11287 if ( (synpred211_Java()) ) { 11288 alt134=1; 11289 } 11290 11291 11292 } 11293 11294 11295 } 11296 11297 11298 } finally {dbg.exitDecision(134);} 11299 11300 switch (alt134) { 11301 case 1 : 11302 dbg.enterAlt(1); 11303 11304 // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER 11305 { 11306 dbg.location(1108,10); 11307 match(input,DOT,FOLLOW_DOT_in_primary6388); if (state.failed) return ; 11308 dbg.location(1108,14); 11309 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6390); if (state.failed) return ; 11310 11311 } 11312 break; 11313 11314 default : 11315 break loop134; 11316 } 11317 } while (true); 11318 } finally {dbg.exitSubRule(134);} 11319 11320 dbg.location(1110,9); 11321 // src/com/google/doclava/parser/Java.g:1110:9: ( identifierSuffix )? 11322 int alt135=2; 11323 try { dbg.enterSubRule(135); 11324 try { dbg.enterDecision(135, decisionCanBacktrack[135]); 11325 11326 try { 11327 isCyclicDecision = true; 11328 alt135 = dfa135.predict(input); 11329 } 11330 catch (NoViableAltException nvae) { 11331 dbg.recognitionException(nvae); 11332 throw nvae; 11333 } 11334 } finally {dbg.exitDecision(135);} 11335 11336 switch (alt135) { 11337 case 1 : 11338 dbg.enterAlt(1); 11339 11340 // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix 11341 { 11342 dbg.location(1110,10); 11343 pushFollow(FOLLOW_identifierSuffix_in_primary6412); 11344 identifierSuffix(); 11345 11346 state._fsp--; 11347 if (state.failed) return ; 11348 11349 } 11350 break; 11351 11352 } 11353 } finally {dbg.exitSubRule(135);} 11354 11355 11356 } 11357 break; 11358 case 4 : 11359 dbg.enterAlt(4); 11360 11361 // src/com/google/doclava/parser/Java.g:1112:9: 'super' superSuffix 11362 { 11363 dbg.location(1112,9); 11364 match(input,SUPER,FOLLOW_SUPER_in_primary6433); if (state.failed) return ; 11365 dbg.location(1113,9); 11366 pushFollow(FOLLOW_superSuffix_in_primary6443); 11367 superSuffix(); 11368 11369 state._fsp--; 11370 if (state.failed) return ; 11371 11372 } 11373 break; 11374 case 5 : 11375 dbg.enterAlt(5); 11376 11377 // src/com/google/doclava/parser/Java.g:1114:9: literal 11378 { 11379 dbg.location(1114,9); 11380 pushFollow(FOLLOW_literal_in_primary6453); 11381 literal(); 11382 11383 state._fsp--; 11384 if (state.failed) return ; 11385 11386 } 11387 break; 11388 case 6 : 11389 dbg.enterAlt(6); 11390 11391 // src/com/google/doclava/parser/Java.g:1115:9: creator 11392 { 11393 dbg.location(1115,9); 11394 pushFollow(FOLLOW_creator_in_primary6463); 11395 creator(); 11396 11397 state._fsp--; 11398 if (state.failed) return ; 11399 11400 } 11401 break; 11402 case 7 : 11403 dbg.enterAlt(7); 11404 11405 // src/com/google/doclava/parser/Java.g:1116:9: primitiveType ( '[' ']' )* '.' 'class' 11406 { 11407 dbg.location(1116,9); 11408 pushFollow(FOLLOW_primitiveType_in_primary6473); 11409 primitiveType(); 11410 11411 state._fsp--; 11412 if (state.failed) return ; 11413 dbg.location(1117,9); 11414 // src/com/google/doclava/parser/Java.g:1117:9: ( '[' ']' )* 11415 try { dbg.enterSubRule(136); 11416 11417 loop136: 11418 do { 11419 int alt136=2; 11420 try { dbg.enterDecision(136, decisionCanBacktrack[136]); 11421 11422 int LA136_0 = input.LA(1); 11423 11424 if ( (LA136_0==LBRACKET) ) { 11425 alt136=1; 11426 } 11427 11428 11429 } finally {dbg.exitDecision(136);} 11430 11431 switch (alt136) { 11432 case 1 : 11433 dbg.enterAlt(1); 11434 11435 // src/com/google/doclava/parser/Java.g:1117:10: '[' ']' 11436 { 11437 dbg.location(1117,10); 11438 match(input,LBRACKET,FOLLOW_LBRACKET_in_primary6484); if (state.failed) return ; 11439 dbg.location(1117,14); 11440 match(input,RBRACKET,FOLLOW_RBRACKET_in_primary6486); if (state.failed) return ; 11441 11442 } 11443 break; 11444 11445 default : 11446 break loop136; 11447 } 11448 } while (true); 11449 } finally {dbg.exitSubRule(136);} 11450 11451 dbg.location(1119,9); 11452 match(input,DOT,FOLLOW_DOT_in_primary6507); if (state.failed) return ; 11453 dbg.location(1119,13); 11454 match(input,CLASS,FOLLOW_CLASS_in_primary6509); if (state.failed) return ; 11455 11456 } 11457 break; 11458 case 8 : 11459 dbg.enterAlt(8); 11460 11461 // src/com/google/doclava/parser/Java.g:1120:9: 'void' '.' 'class' 11462 { 11463 dbg.location(1120,9); 11464 match(input,VOID,FOLLOW_VOID_in_primary6519); if (state.failed) return ; 11465 dbg.location(1120,16); 11466 match(input,DOT,FOLLOW_DOT_in_primary6521); if (state.failed) return ; 11467 dbg.location(1120,20); 11468 match(input,CLASS,FOLLOW_CLASS_in_primary6523); if (state.failed) return ; 11469 11470 } 11471 break; 11472 11473 } 11474 } 11475 catch (RecognitionException re) { 11476 reportError(re); 11477 recover(input,re); 11478 } 11479 finally { 11480 if ( state.backtracking>0 ) { memoize(input, 89, primary_StartIndex); } 11481 } 11482 dbg.location(1121, 5); 11483 11484 } 11485 finally { 11486 dbg.exitRule(getGrammarFileName(), "primary"); 11487 decRuleLevel(); 11488 if ( getRuleLevel()==0 ) {dbg.terminate();} 11489 } 11490 11491 return ; 11492 } 11493 // $ANTLR end "primary" 11494 11495 11496 // $ANTLR start "superSuffix" 11497 // src/com/google/doclava/parser/Java.g:1124:1: superSuffix : ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? ); superSuffix()11498 public final void superSuffix() throws RecognitionException { 11499 int superSuffix_StartIndex = input.index(); 11500 try { dbg.enterRule(getGrammarFileName(), "superSuffix"); 11501 if ( getRuleLevel()==0 ) {dbg.commence();} 11502 incRuleLevel(); 11503 dbg.location(1124, 1); 11504 11505 try { 11506 if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; } 11507 // src/com/google/doclava/parser/Java.g:1125:5: ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? ) 11508 int alt140=2; 11509 try { dbg.enterDecision(140, decisionCanBacktrack[140]); 11510 11511 int LA140_0 = input.LA(1); 11512 11513 if ( (LA140_0==LPAREN) ) { 11514 alt140=1; 11515 } 11516 else if ( (LA140_0==DOT) ) { 11517 alt140=2; 11518 } 11519 else { 11520 if (state.backtracking>0) {state.failed=true; return ;} 11521 NoViableAltException nvae = 11522 new NoViableAltException("", 140, 0, input); 11523 11524 dbg.recognitionException(nvae); 11525 throw nvae; 11526 } 11527 } finally {dbg.exitDecision(140);} 11528 11529 switch (alt140) { 11530 case 1 : 11531 dbg.enterAlt(1); 11532 11533 // src/com/google/doclava/parser/Java.g:1125:9: arguments 11534 { 11535 dbg.location(1125,9); 11536 pushFollow(FOLLOW_arguments_in_superSuffix6543); 11537 arguments(); 11538 11539 state._fsp--; 11540 if (state.failed) return ; 11541 11542 } 11543 break; 11544 case 2 : 11545 dbg.enterAlt(2); 11546 11547 // src/com/google/doclava/parser/Java.g:1126:9: '.' ( typeArguments )? IDENTIFIER ( arguments )? 11548 { 11549 dbg.location(1126,9); 11550 match(input,DOT,FOLLOW_DOT_in_superSuffix6553); if (state.failed) return ; 11551 dbg.location(1126,13); 11552 // src/com/google/doclava/parser/Java.g:1126:13: ( typeArguments )? 11553 int alt138=2; 11554 try { dbg.enterSubRule(138); 11555 try { dbg.enterDecision(138, decisionCanBacktrack[138]); 11556 11557 int LA138_0 = input.LA(1); 11558 11559 if ( (LA138_0==LT) ) { 11560 alt138=1; 11561 } 11562 } finally {dbg.exitDecision(138);} 11563 11564 switch (alt138) { 11565 case 1 : 11566 dbg.enterAlt(1); 11567 11568 // src/com/google/doclava/parser/Java.g:1126:14: typeArguments 11569 { 11570 dbg.location(1126,14); 11571 pushFollow(FOLLOW_typeArguments_in_superSuffix6556); 11572 typeArguments(); 11573 11574 state._fsp--; 11575 if (state.failed) return ; 11576 11577 } 11578 break; 11579 11580 } 11581 } finally {dbg.exitSubRule(138);} 11582 11583 dbg.location(1128,9); 11584 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_superSuffix6577); if (state.failed) return ; 11585 dbg.location(1129,9); 11586 // src/com/google/doclava/parser/Java.g:1129:9: ( arguments )? 11587 int alt139=2; 11588 try { dbg.enterSubRule(139); 11589 try { dbg.enterDecision(139, decisionCanBacktrack[139]); 11590 11591 int LA139_0 = input.LA(1); 11592 11593 if ( (LA139_0==LPAREN) ) { 11594 alt139=1; 11595 } 11596 } finally {dbg.exitDecision(139);} 11597 11598 switch (alt139) { 11599 case 1 : 11600 dbg.enterAlt(1); 11601 11602 // src/com/google/doclava/parser/Java.g:1129:10: arguments 11603 { 11604 dbg.location(1129,10); 11605 pushFollow(FOLLOW_arguments_in_superSuffix6588); 11606 arguments(); 11607 11608 state._fsp--; 11609 if (state.failed) return ; 11610 11611 } 11612 break; 11613 11614 } 11615 } finally {dbg.exitSubRule(139);} 11616 11617 11618 } 11619 break; 11620 11621 } 11622 } 11623 catch (RecognitionException re) { 11624 reportError(re); 11625 recover(input,re); 11626 } 11627 finally { 11628 if ( state.backtracking>0 ) { memoize(input, 90, superSuffix_StartIndex); } 11629 } 11630 dbg.location(1131, 5); 11631 11632 } 11633 finally { 11634 dbg.exitRule(getGrammarFileName(), "superSuffix"); 11635 decRuleLevel(); 11636 if ( getRuleLevel()==0 ) {dbg.terminate();} 11637 } 11638 11639 return ; 11640 } 11641 // $ANTLR end "superSuffix" 11642 11643 11644 // $ANTLR start "identifierSuffix" 11645 // src/com/google/doclava/parser/Java.g:1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator ); identifierSuffix()11646 public final void identifierSuffix() throws RecognitionException { 11647 int identifierSuffix_StartIndex = input.index(); 11648 try { dbg.enterRule(getGrammarFileName(), "identifierSuffix"); 11649 if ( getRuleLevel()==0 ) {dbg.commence();} 11650 incRuleLevel(); 11651 dbg.location(1134, 1); 11652 11653 try { 11654 if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; } 11655 // src/com/google/doclava/parser/Java.g:1135:5: ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator ) 11656 int alt143=8; 11657 try { dbg.enterDecision(143, decisionCanBacktrack[143]); 11658 11659 try { 11660 isCyclicDecision = true; 11661 alt143 = dfa143.predict(input); 11662 } 11663 catch (NoViableAltException nvae) { 11664 dbg.recognitionException(nvae); 11665 throw nvae; 11666 } 11667 } finally {dbg.exitDecision(143);} 11668 11669 switch (alt143) { 11670 case 1 : 11671 dbg.enterAlt(1); 11672 11673 // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+ '.' 'class' 11674 { 11675 dbg.location(1135,9); 11676 // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+ 11677 int cnt141=0; 11678 try { dbg.enterSubRule(141); 11679 11680 loop141: 11681 do { 11682 int alt141=2; 11683 try { dbg.enterDecision(141, decisionCanBacktrack[141]); 11684 11685 int LA141_0 = input.LA(1); 11686 11687 if ( (LA141_0==LBRACKET) ) { 11688 alt141=1; 11689 } 11690 11691 11692 } finally {dbg.exitDecision(141);} 11693 11694 switch (alt141) { 11695 case 1 : 11696 dbg.enterAlt(1); 11697 11698 // src/com/google/doclava/parser/Java.g:1135:10: '[' ']' 11699 { 11700 dbg.location(1135,10); 11701 match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6620); if (state.failed) return ; 11702 dbg.location(1135,14); 11703 match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6622); if (state.failed) return ; 11704 11705 } 11706 break; 11707 11708 default : 11709 if ( cnt141 >= 1 ) break loop141; 11710 if (state.backtracking>0) {state.failed=true; return ;} 11711 EarlyExitException eee = 11712 new EarlyExitException(141, input); 11713 dbg.recognitionException(eee); 11714 11715 throw eee; 11716 } 11717 cnt141++; 11718 } while (true); 11719 } finally {dbg.exitSubRule(141);} 11720 11721 dbg.location(1137,9); 11722 match(input,DOT,FOLLOW_DOT_in_identifierSuffix6643); if (state.failed) return ; 11723 dbg.location(1137,13); 11724 match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6645); if (state.failed) return ; 11725 11726 } 11727 break; 11728 case 2 : 11729 dbg.enterAlt(2); 11730 11731 // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+ 11732 { 11733 dbg.location(1138,9); 11734 // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+ 11735 int cnt142=0; 11736 try { dbg.enterSubRule(142); 11737 11738 loop142: 11739 do { 11740 int alt142=2; 11741 try { dbg.enterDecision(142, decisionCanBacktrack[142]); 11742 11743 try { 11744 isCyclicDecision = true; 11745 alt142 = dfa142.predict(input); 11746 } 11747 catch (NoViableAltException nvae) { 11748 dbg.recognitionException(nvae); 11749 throw nvae; 11750 } 11751 } finally {dbg.exitDecision(142);} 11752 11753 switch (alt142) { 11754 case 1 : 11755 dbg.enterAlt(1); 11756 11757 // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']' 11758 { 11759 dbg.location(1138,10); 11760 match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6656); if (state.failed) return ; 11761 dbg.location(1138,14); 11762 pushFollow(FOLLOW_expression_in_identifierSuffix6658); 11763 expression(); 11764 11765 state._fsp--; 11766 if (state.failed) return ; 11767 dbg.location(1138,25); 11768 match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6660); if (state.failed) return ; 11769 11770 } 11771 break; 11772 11773 default : 11774 if ( cnt142 >= 1 ) break loop142; 11775 if (state.backtracking>0) {state.failed=true; return ;} 11776 EarlyExitException eee = 11777 new EarlyExitException(142, input); 11778 dbg.recognitionException(eee); 11779 11780 throw eee; 11781 } 11782 cnt142++; 11783 } while (true); 11784 } finally {dbg.exitSubRule(142);} 11785 11786 11787 } 11788 break; 11789 case 3 : 11790 dbg.enterAlt(3); 11791 11792 // src/com/google/doclava/parser/Java.g:1140:9: arguments 11793 { 11794 dbg.location(1140,9); 11795 pushFollow(FOLLOW_arguments_in_identifierSuffix6681); 11796 arguments(); 11797 11798 state._fsp--; 11799 if (state.failed) return ; 11800 11801 } 11802 break; 11803 case 4 : 11804 dbg.enterAlt(4); 11805 11806 // src/com/google/doclava/parser/Java.g:1141:9: '.' 'class' 11807 { 11808 dbg.location(1141,9); 11809 match(input,DOT,FOLLOW_DOT_in_identifierSuffix6691); if (state.failed) return ; 11810 dbg.location(1141,13); 11811 match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6693); if (state.failed) return ; 11812 11813 } 11814 break; 11815 case 5 : 11816 dbg.enterAlt(5); 11817 11818 // src/com/google/doclava/parser/Java.g:1142:9: '.' nonWildcardTypeArguments IDENTIFIER arguments 11819 { 11820 dbg.location(1142,9); 11821 match(input,DOT,FOLLOW_DOT_in_identifierSuffix6703); if (state.failed) return ; 11822 dbg.location(1142,13); 11823 pushFollow(FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705); 11824 nonWildcardTypeArguments(); 11825 11826 state._fsp--; 11827 if (state.failed) return ; 11828 dbg.location(1142,38); 11829 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierSuffix6707); if (state.failed) return ; 11830 dbg.location(1142,49); 11831 pushFollow(FOLLOW_arguments_in_identifierSuffix6709); 11832 arguments(); 11833 11834 state._fsp--; 11835 if (state.failed) return ; 11836 11837 } 11838 break; 11839 case 6 : 11840 dbg.enterAlt(6); 11841 11842 // src/com/google/doclava/parser/Java.g:1143:9: '.' 'this' 11843 { 11844 dbg.location(1143,9); 11845 match(input,DOT,FOLLOW_DOT_in_identifierSuffix6719); if (state.failed) return ; 11846 dbg.location(1143,13); 11847 match(input,THIS,FOLLOW_THIS_in_identifierSuffix6721); if (state.failed) return ; 11848 11849 } 11850 break; 11851 case 7 : 11852 dbg.enterAlt(7); 11853 11854 // src/com/google/doclava/parser/Java.g:1144:9: '.' 'super' arguments 11855 { 11856 dbg.location(1144,9); 11857 match(input,DOT,FOLLOW_DOT_in_identifierSuffix6731); if (state.failed) return ; 11858 dbg.location(1144,13); 11859 match(input,SUPER,FOLLOW_SUPER_in_identifierSuffix6733); if (state.failed) return ; 11860 dbg.location(1144,21); 11861 pushFollow(FOLLOW_arguments_in_identifierSuffix6735); 11862 arguments(); 11863 11864 state._fsp--; 11865 if (state.failed) return ; 11866 11867 } 11868 break; 11869 case 8 : 11870 dbg.enterAlt(8); 11871 11872 // src/com/google/doclava/parser/Java.g:1145:9: innerCreator 11873 { 11874 dbg.location(1145,9); 11875 pushFollow(FOLLOW_innerCreator_in_identifierSuffix6745); 11876 innerCreator(); 11877 11878 state._fsp--; 11879 if (state.failed) return ; 11880 11881 } 11882 break; 11883 11884 } 11885 } 11886 catch (RecognitionException re) { 11887 reportError(re); 11888 recover(input,re); 11889 } 11890 finally { 11891 if ( state.backtracking>0 ) { memoize(input, 91, identifierSuffix_StartIndex); } 11892 } 11893 dbg.location(1146, 5); 11894 11895 } 11896 finally { 11897 dbg.exitRule(getGrammarFileName(), "identifierSuffix"); 11898 decRuleLevel(); 11899 if ( getRuleLevel()==0 ) {dbg.terminate();} 11900 } 11901 11902 return ; 11903 } 11904 // $ANTLR end "identifierSuffix" 11905 11906 11907 // $ANTLR start "selector" 11908 // src/com/google/doclava/parser/Java.g:1149:1: selector : ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' ); selector()11909 public final void selector() throws RecognitionException { 11910 int selector_StartIndex = input.index(); 11911 try { dbg.enterRule(getGrammarFileName(), "selector"); 11912 if ( getRuleLevel()==0 ) {dbg.commence();} 11913 incRuleLevel(); 11914 dbg.location(1149, 1); 11915 11916 try { 11917 if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; } 11918 // src/com/google/doclava/parser/Java.g:1150:5: ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' ) 11919 int alt145=5; 11920 try { dbg.enterDecision(145, decisionCanBacktrack[145]); 11921 11922 int LA145_0 = input.LA(1); 11923 11924 if ( (LA145_0==DOT) ) { 11925 switch ( input.LA(2) ) { 11926 case IDENTIFIER: 11927 { 11928 alt145=1; 11929 } 11930 break; 11931 case THIS: 11932 { 11933 alt145=2; 11934 } 11935 break; 11936 case SUPER: 11937 { 11938 alt145=3; 11939 } 11940 break; 11941 case NEW: 11942 { 11943 alt145=4; 11944 } 11945 break; 11946 default: 11947 if (state.backtracking>0) {state.failed=true; return ;} 11948 NoViableAltException nvae = 11949 new NoViableAltException("", 145, 1, input); 11950 11951 dbg.recognitionException(nvae); 11952 throw nvae; 11953 } 11954 11955 } 11956 else if ( (LA145_0==LBRACKET) ) { 11957 alt145=5; 11958 } 11959 else { 11960 if (state.backtracking>0) {state.failed=true; return ;} 11961 NoViableAltException nvae = 11962 new NoViableAltException("", 145, 0, input); 11963 11964 dbg.recognitionException(nvae); 11965 throw nvae; 11966 } 11967 } finally {dbg.exitDecision(145);} 11968 11969 switch (alt145) { 11970 case 1 : 11971 dbg.enterAlt(1); 11972 11973 // src/com/google/doclava/parser/Java.g:1150:9: '.' IDENTIFIER ( arguments )? 11974 { 11975 dbg.location(1150,9); 11976 match(input,DOT,FOLLOW_DOT_in_selector6765); if (state.failed) return ; 11977 dbg.location(1150,13); 11978 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_selector6767); if (state.failed) return ; 11979 dbg.location(1151,9); 11980 // src/com/google/doclava/parser/Java.g:1151:9: ( arguments )? 11981 int alt144=2; 11982 try { dbg.enterSubRule(144); 11983 try { dbg.enterDecision(144, decisionCanBacktrack[144]); 11984 11985 int LA144_0 = input.LA(1); 11986 11987 if ( (LA144_0==LPAREN) ) { 11988 alt144=1; 11989 } 11990 } finally {dbg.exitDecision(144);} 11991 11992 switch (alt144) { 11993 case 1 : 11994 dbg.enterAlt(1); 11995 11996 // src/com/google/doclava/parser/Java.g:1151:10: arguments 11997 { 11998 dbg.location(1151,10); 11999 pushFollow(FOLLOW_arguments_in_selector6778); 12000 arguments(); 12001 12002 state._fsp--; 12003 if (state.failed) return ; 12004 12005 } 12006 break; 12007 12008 } 12009 } finally {dbg.exitSubRule(144);} 12010 12011 12012 } 12013 break; 12014 case 2 : 12015 dbg.enterAlt(2); 12016 12017 // src/com/google/doclava/parser/Java.g:1153:9: '.' 'this' 12018 { 12019 dbg.location(1153,9); 12020 match(input,DOT,FOLLOW_DOT_in_selector6799); if (state.failed) return ; 12021 dbg.location(1153,13); 12022 match(input,THIS,FOLLOW_THIS_in_selector6801); if (state.failed) return ; 12023 12024 } 12025 break; 12026 case 3 : 12027 dbg.enterAlt(3); 12028 12029 // src/com/google/doclava/parser/Java.g:1154:9: '.' 'super' superSuffix 12030 { 12031 dbg.location(1154,9); 12032 match(input,DOT,FOLLOW_DOT_in_selector6811); if (state.failed) return ; 12033 dbg.location(1154,13); 12034 match(input,SUPER,FOLLOW_SUPER_in_selector6813); if (state.failed) return ; 12035 dbg.location(1155,9); 12036 pushFollow(FOLLOW_superSuffix_in_selector6823); 12037 superSuffix(); 12038 12039 state._fsp--; 12040 if (state.failed) return ; 12041 12042 } 12043 break; 12044 case 4 : 12045 dbg.enterAlt(4); 12046 12047 // src/com/google/doclava/parser/Java.g:1156:9: innerCreator 12048 { 12049 dbg.location(1156,9); 12050 pushFollow(FOLLOW_innerCreator_in_selector6833); 12051 innerCreator(); 12052 12053 state._fsp--; 12054 if (state.failed) return ; 12055 12056 } 12057 break; 12058 case 5 : 12059 dbg.enterAlt(5); 12060 12061 // src/com/google/doclava/parser/Java.g:1157:9: '[' expression ']' 12062 { 12063 dbg.location(1157,9); 12064 match(input,LBRACKET,FOLLOW_LBRACKET_in_selector6843); if (state.failed) return ; 12065 dbg.location(1157,13); 12066 pushFollow(FOLLOW_expression_in_selector6845); 12067 expression(); 12068 12069 state._fsp--; 12070 if (state.failed) return ; 12071 dbg.location(1157,24); 12072 match(input,RBRACKET,FOLLOW_RBRACKET_in_selector6847); if (state.failed) return ; 12073 12074 } 12075 break; 12076 12077 } 12078 } 12079 catch (RecognitionException re) { 12080 reportError(re); 12081 recover(input,re); 12082 } 12083 finally { 12084 if ( state.backtracking>0 ) { memoize(input, 92, selector_StartIndex); } 12085 } 12086 dbg.location(1158, 5); 12087 12088 } 12089 finally { 12090 dbg.exitRule(getGrammarFileName(), "selector"); 12091 decRuleLevel(); 12092 if ( getRuleLevel()==0 ) {dbg.terminate();} 12093 } 12094 12095 return ; 12096 } 12097 // $ANTLR end "selector" 12098 12099 12100 // $ANTLR start "creator" 12101 // src/com/google/doclava/parser/Java.g:1160:1: creator : ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator ); creator()12102 public final void creator() throws RecognitionException { 12103 int creator_StartIndex = input.index(); 12104 try { dbg.enterRule(getGrammarFileName(), "creator"); 12105 if ( getRuleLevel()==0 ) {dbg.commence();} 12106 incRuleLevel(); 12107 dbg.location(1160, 1); 12108 12109 try { 12110 if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; } 12111 // src/com/google/doclava/parser/Java.g:1161:5: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator ) 12112 int alt146=3; 12113 try { dbg.enterDecision(146, decisionCanBacktrack[146]); 12114 12115 int LA146_0 = input.LA(1); 12116 12117 if ( (LA146_0==NEW) ) { 12118 int LA146_1 = input.LA(2); 12119 12120 if ( (synpred236_Java()) ) { 12121 alt146=1; 12122 } 12123 else if ( (synpred237_Java()) ) { 12124 alt146=2; 12125 } 12126 else if ( (true) ) { 12127 alt146=3; 12128 } 12129 else { 12130 if (state.backtracking>0) {state.failed=true; return ;} 12131 NoViableAltException nvae = 12132 new NoViableAltException("", 146, 1, input); 12133 12134 dbg.recognitionException(nvae); 12135 throw nvae; 12136 } 12137 } 12138 else { 12139 if (state.backtracking>0) {state.failed=true; return ;} 12140 NoViableAltException nvae = 12141 new NoViableAltException("", 146, 0, input); 12142 12143 dbg.recognitionException(nvae); 12144 throw nvae; 12145 } 12146 } finally {dbg.exitDecision(146);} 12147 12148 switch (alt146) { 12149 case 1 : 12150 dbg.enterAlt(1); 12151 12152 // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest 12153 { 12154 dbg.location(1161,9); 12155 match(input,NEW,FOLLOW_NEW_in_creator6866); if (state.failed) return ; 12156 dbg.location(1161,15); 12157 pushFollow(FOLLOW_nonWildcardTypeArguments_in_creator6868); 12158 nonWildcardTypeArguments(); 12159 12160 state._fsp--; 12161 if (state.failed) return ; 12162 dbg.location(1161,40); 12163 pushFollow(FOLLOW_classOrInterfaceType_in_creator6870); 12164 classOrInterfaceType(); 12165 12166 state._fsp--; 12167 if (state.failed) return ; 12168 dbg.location(1161,61); 12169 pushFollow(FOLLOW_classCreatorRest_in_creator6872); 12170 classCreatorRest(); 12171 12172 state._fsp--; 12173 if (state.failed) return ; 12174 12175 } 12176 break; 12177 case 2 : 12178 dbg.enterAlt(2); 12179 12180 // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest 12181 { 12182 dbg.location(1162,9); 12183 match(input,NEW,FOLLOW_NEW_in_creator6882); if (state.failed) return ; 12184 dbg.location(1162,15); 12185 pushFollow(FOLLOW_classOrInterfaceType_in_creator6884); 12186 classOrInterfaceType(); 12187 12188 state._fsp--; 12189 if (state.failed) return ; 12190 dbg.location(1162,36); 12191 pushFollow(FOLLOW_classCreatorRest_in_creator6886); 12192 classCreatorRest(); 12193 12194 state._fsp--; 12195 if (state.failed) return ; 12196 12197 } 12198 break; 12199 case 3 : 12200 dbg.enterAlt(3); 12201 12202 // src/com/google/doclava/parser/Java.g:1163:9: arrayCreator 12203 { 12204 dbg.location(1163,9); 12205 pushFollow(FOLLOW_arrayCreator_in_creator6896); 12206 arrayCreator(); 12207 12208 state._fsp--; 12209 if (state.failed) return ; 12210 12211 } 12212 break; 12213 12214 } 12215 } 12216 catch (RecognitionException re) { 12217 reportError(re); 12218 recover(input,re); 12219 } 12220 finally { 12221 if ( state.backtracking>0 ) { memoize(input, 93, creator_StartIndex); } 12222 } 12223 dbg.location(1164, 5); 12224 12225 } 12226 finally { 12227 dbg.exitRule(getGrammarFileName(), "creator"); 12228 decRuleLevel(); 12229 if ( getRuleLevel()==0 ) {dbg.terminate();} 12230 } 12231 12232 return ; 12233 } 12234 // $ANTLR end "creator" 12235 12236 12237 // $ANTLR start "arrayCreator" 12238 // src/com/google/doclava/parser/Java.g:1166:1: arrayCreator : ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* ); arrayCreator()12239 public final void arrayCreator() throws RecognitionException { 12240 int arrayCreator_StartIndex = input.index(); 12241 try { dbg.enterRule(getGrammarFileName(), "arrayCreator"); 12242 if ( getRuleLevel()==0 ) {dbg.commence();} 12243 incRuleLevel(); 12244 dbg.location(1166, 1); 12245 12246 try { 12247 if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; } 12248 // src/com/google/doclava/parser/Java.g:1167:5: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* ) 12249 int alt150=2; 12250 try { dbg.enterDecision(150, decisionCanBacktrack[150]); 12251 12252 int LA150_0 = input.LA(1); 12253 12254 if ( (LA150_0==NEW) ) { 12255 int LA150_1 = input.LA(2); 12256 12257 if ( (synpred239_Java()) ) { 12258 alt150=1; 12259 } 12260 else if ( (true) ) { 12261 alt150=2; 12262 } 12263 else { 12264 if (state.backtracking>0) {state.failed=true; return ;} 12265 NoViableAltException nvae = 12266 new NoViableAltException("", 150, 1, input); 12267 12268 dbg.recognitionException(nvae); 12269 throw nvae; 12270 } 12271 } 12272 else { 12273 if (state.backtracking>0) {state.failed=true; return ;} 12274 NoViableAltException nvae = 12275 new NoViableAltException("", 150, 0, input); 12276 12277 dbg.recognitionException(nvae); 12278 throw nvae; 12279 } 12280 } finally {dbg.exitDecision(150);} 12281 12282 switch (alt150) { 12283 case 1 : 12284 dbg.enterAlt(1); 12285 12286 // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer 12287 { 12288 dbg.location(1167,9); 12289 match(input,NEW,FOLLOW_NEW_in_arrayCreator6915); if (state.failed) return ; 12290 dbg.location(1167,15); 12291 pushFollow(FOLLOW_createdName_in_arrayCreator6917); 12292 createdName(); 12293 12294 state._fsp--; 12295 if (state.failed) return ; 12296 dbg.location(1168,9); 12297 match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6927); if (state.failed) return ; 12298 dbg.location(1168,13); 12299 match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6929); if (state.failed) return ; 12300 dbg.location(1169,9); 12301 // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )* 12302 try { dbg.enterSubRule(147); 12303 12304 loop147: 12305 do { 12306 int alt147=2; 12307 try { dbg.enterDecision(147, decisionCanBacktrack[147]); 12308 12309 int LA147_0 = input.LA(1); 12310 12311 if ( (LA147_0==LBRACKET) ) { 12312 alt147=1; 12313 } 12314 12315 12316 } finally {dbg.exitDecision(147);} 12317 12318 switch (alt147) { 12319 case 1 : 12320 dbg.enterAlt(1); 12321 12322 // src/com/google/doclava/parser/Java.g:1169:10: '[' ']' 12323 { 12324 dbg.location(1169,10); 12325 match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6940); if (state.failed) return ; 12326 dbg.location(1169,14); 12327 match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6942); if (state.failed) return ; 12328 12329 } 12330 break; 12331 12332 default : 12333 break loop147; 12334 } 12335 } while (true); 12336 } finally {dbg.exitSubRule(147);} 12337 12338 dbg.location(1171,9); 12339 pushFollow(FOLLOW_arrayInitializer_in_arrayCreator6963); 12340 arrayInitializer(); 12341 12342 state._fsp--; 12343 if (state.failed) return ; 12344 12345 } 12346 break; 12347 case 2 : 12348 dbg.enterAlt(2); 12349 12350 // src/com/google/doclava/parser/Java.g:1173:9: 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* 12351 { 12352 dbg.location(1173,9); 12353 match(input,NEW,FOLLOW_NEW_in_arrayCreator6974); if (state.failed) return ; 12354 dbg.location(1173,15); 12355 pushFollow(FOLLOW_createdName_in_arrayCreator6976); 12356 createdName(); 12357 12358 state._fsp--; 12359 if (state.failed) return ; 12360 dbg.location(1174,9); 12361 match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6986); if (state.failed) return ; 12362 dbg.location(1174,13); 12363 pushFollow(FOLLOW_expression_in_arrayCreator6988); 12364 expression(); 12365 12366 state._fsp--; 12367 if (state.failed) return ; 12368 dbg.location(1175,9); 12369 match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6998); if (state.failed) return ; 12370 dbg.location(1176,9); 12371 // src/com/google/doclava/parser/Java.g:1176:9: ( '[' expression ']' )* 12372 try { dbg.enterSubRule(148); 12373 12374 loop148: 12375 do { 12376 int alt148=2; 12377 try { dbg.enterDecision(148, decisionCanBacktrack[148]); 12378 12379 try { 12380 isCyclicDecision = true; 12381 alt148 = dfa148.predict(input); 12382 } 12383 catch (NoViableAltException nvae) { 12384 dbg.recognitionException(nvae); 12385 throw nvae; 12386 } 12387 } finally {dbg.exitDecision(148);} 12388 12389 switch (alt148) { 12390 case 1 : 12391 dbg.enterAlt(1); 12392 12393 // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']' 12394 { 12395 dbg.location(1176,13); 12396 match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7012); if (state.failed) return ; 12397 dbg.location(1176,17); 12398 pushFollow(FOLLOW_expression_in_arrayCreator7014); 12399 expression(); 12400 12401 state._fsp--; 12402 if (state.failed) return ; 12403 dbg.location(1177,13); 12404 match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7028); if (state.failed) return ; 12405 12406 } 12407 break; 12408 12409 default : 12410 break loop148; 12411 } 12412 } while (true); 12413 } finally {dbg.exitSubRule(148);} 12414 12415 dbg.location(1179,9); 12416 // src/com/google/doclava/parser/Java.g:1179:9: ( '[' ']' )* 12417 try { dbg.enterSubRule(149); 12418 12419 loop149: 12420 do { 12421 int alt149=2; 12422 try { dbg.enterDecision(149, decisionCanBacktrack[149]); 12423 12424 int LA149_0 = input.LA(1); 12425 12426 if ( (LA149_0==LBRACKET) ) { 12427 int LA149_2 = input.LA(2); 12428 12429 if ( (LA149_2==RBRACKET) ) { 12430 alt149=1; 12431 } 12432 12433 12434 } 12435 12436 12437 } finally {dbg.exitDecision(149);} 12438 12439 switch (alt149) { 12440 case 1 : 12441 dbg.enterAlt(1); 12442 12443 // src/com/google/doclava/parser/Java.g:1179:10: '[' ']' 12444 { 12445 dbg.location(1179,10); 12446 match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7050); if (state.failed) return ; 12447 dbg.location(1179,14); 12448 match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7052); if (state.failed) return ; 12449 12450 } 12451 break; 12452 12453 default : 12454 break loop149; 12455 } 12456 } while (true); 12457 } finally {dbg.exitSubRule(149);} 12458 12459 12460 } 12461 break; 12462 12463 } 12464 } 12465 catch (RecognitionException re) { 12466 reportError(re); 12467 recover(input,re); 12468 } 12469 finally { 12470 if ( state.backtracking>0 ) { memoize(input, 94, arrayCreator_StartIndex); } 12471 } 12472 dbg.location(1181, 5); 12473 12474 } 12475 finally { 12476 dbg.exitRule(getGrammarFileName(), "arrayCreator"); 12477 decRuleLevel(); 12478 if ( getRuleLevel()==0 ) {dbg.terminate();} 12479 } 12480 12481 return ; 12482 } 12483 // $ANTLR end "arrayCreator" 12484 12485 12486 // $ANTLR start "variableInitializer" 12487 // src/com/google/doclava/parser/Java.g:1183:1: variableInitializer : ( arrayInitializer | expression ); variableInitializer()12488 public final void variableInitializer() throws RecognitionException { 12489 int variableInitializer_StartIndex = input.index(); 12490 try { dbg.enterRule(getGrammarFileName(), "variableInitializer"); 12491 if ( getRuleLevel()==0 ) {dbg.commence();} 12492 incRuleLevel(); 12493 dbg.location(1183, 1); 12494 12495 try { 12496 if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; } 12497 // src/com/google/doclava/parser/Java.g:1184:5: ( arrayInitializer | expression ) 12498 int alt151=2; 12499 try { dbg.enterDecision(151, decisionCanBacktrack[151]); 12500 12501 int LA151_0 = input.LA(1); 12502 12503 if ( (LA151_0==LBRACE) ) { 12504 alt151=1; 12505 } 12506 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)) ) { 12507 alt151=2; 12508 } 12509 else { 12510 if (state.backtracking>0) {state.failed=true; return ;} 12511 NoViableAltException nvae = 12512 new NoViableAltException("", 151, 0, input); 12513 12514 dbg.recognitionException(nvae); 12515 throw nvae; 12516 } 12517 } finally {dbg.exitDecision(151);} 12518 12519 switch (alt151) { 12520 case 1 : 12521 dbg.enterAlt(1); 12522 12523 // src/com/google/doclava/parser/Java.g:1184:9: arrayInitializer 12524 { 12525 dbg.location(1184,9); 12526 pushFollow(FOLLOW_arrayInitializer_in_variableInitializer7082); 12527 arrayInitializer(); 12528 12529 state._fsp--; 12530 if (state.failed) return ; 12531 12532 } 12533 break; 12534 case 2 : 12535 dbg.enterAlt(2); 12536 12537 // src/com/google/doclava/parser/Java.g:1185:9: expression 12538 { 12539 dbg.location(1185,9); 12540 pushFollow(FOLLOW_expression_in_variableInitializer7092); 12541 expression(); 12542 12543 state._fsp--; 12544 if (state.failed) return ; 12545 12546 } 12547 break; 12548 12549 } 12550 } 12551 catch (RecognitionException re) { 12552 reportError(re); 12553 recover(input,re); 12554 } 12555 finally { 12556 if ( state.backtracking>0 ) { memoize(input, 95, variableInitializer_StartIndex); } 12557 } 12558 dbg.location(1186, 5); 12559 12560 } 12561 finally { 12562 dbg.exitRule(getGrammarFileName(), "variableInitializer"); 12563 decRuleLevel(); 12564 if ( getRuleLevel()==0 ) {dbg.terminate();} 12565 } 12566 12567 return ; 12568 } 12569 // $ANTLR end "variableInitializer" 12570 12571 12572 // $ANTLR start "arrayInitializer" 12573 // src/com/google/doclava/parser/Java.g:1188:1: arrayInitializer : '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ; arrayInitializer()12574 public final void arrayInitializer() throws RecognitionException { 12575 int arrayInitializer_StartIndex = input.index(); 12576 try { dbg.enterRule(getGrammarFileName(), "arrayInitializer"); 12577 if ( getRuleLevel()==0 ) {dbg.commence();} 12578 incRuleLevel(); 12579 dbg.location(1188, 1); 12580 12581 try { 12582 if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; } 12583 // src/com/google/doclava/parser/Java.g:1189:5: ( '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ) 12584 dbg.enterAlt(1); 12585 12586 // src/com/google/doclava/parser/Java.g:1189:9: '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' 12587 { 12588 dbg.location(1189,9); 12589 match(input,LBRACE,FOLLOW_LBRACE_in_arrayInitializer7111); if (state.failed) return ; 12590 dbg.location(1190,13); 12591 // src/com/google/doclava/parser/Java.g:1190:13: ( variableInitializer ( ',' variableInitializer )* )? 12592 int alt153=2; 12593 try { dbg.enterSubRule(153); 12594 try { dbg.enterDecision(153, decisionCanBacktrack[153]); 12595 12596 int LA153_0 = input.LA(1); 12597 12598 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)) ) { 12599 alt153=1; 12600 } 12601 } finally {dbg.exitDecision(153);} 12602 12603 switch (alt153) { 12604 case 1 : 12605 dbg.enterAlt(1); 12606 12607 // src/com/google/doclava/parser/Java.g:1190:14: variableInitializer ( ',' variableInitializer )* 12608 { 12609 dbg.location(1190,14); 12610 pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7126); 12611 variableInitializer(); 12612 12613 state._fsp--; 12614 if (state.failed) return ; 12615 dbg.location(1191,17); 12616 // src/com/google/doclava/parser/Java.g:1191:17: ( ',' variableInitializer )* 12617 try { dbg.enterSubRule(152); 12618 12619 loop152: 12620 do { 12621 int alt152=2; 12622 try { dbg.enterDecision(152, decisionCanBacktrack[152]); 12623 12624 int LA152_0 = input.LA(1); 12625 12626 if ( (LA152_0==COMMA) ) { 12627 int LA152_1 = input.LA(2); 12628 12629 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)) ) { 12630 alt152=1; 12631 } 12632 12633 12634 } 12635 12636 12637 } finally {dbg.exitDecision(152);} 12638 12639 switch (alt152) { 12640 case 1 : 12641 dbg.enterAlt(1); 12642 12643 // src/com/google/doclava/parser/Java.g:1191:18: ',' variableInitializer 12644 { 12645 dbg.location(1191,18); 12646 match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7145); if (state.failed) return ; 12647 dbg.location(1191,22); 12648 pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7147); 12649 variableInitializer(); 12650 12651 state._fsp--; 12652 if (state.failed) return ; 12653 12654 } 12655 break; 12656 12657 default : 12658 break loop152; 12659 } 12660 } while (true); 12661 } finally {dbg.exitSubRule(152);} 12662 12663 12664 } 12665 break; 12666 12667 } 12668 } finally {dbg.exitSubRule(153);} 12669 12670 dbg.location(1194,13); 12671 // src/com/google/doclava/parser/Java.g:1194:13: ( ',' )? 12672 int alt154=2; 12673 try { dbg.enterSubRule(154); 12674 try { dbg.enterDecision(154, decisionCanBacktrack[154]); 12675 12676 int LA154_0 = input.LA(1); 12677 12678 if ( (LA154_0==COMMA) ) { 12679 alt154=1; 12680 } 12681 } finally {dbg.exitDecision(154);} 12682 12683 switch (alt154) { 12684 case 1 : 12685 dbg.enterAlt(1); 12686 12687 // src/com/google/doclava/parser/Java.g:1194:14: ',' 12688 { 12689 dbg.location(1194,14); 12690 match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7196); if (state.failed) return ; 12691 12692 } 12693 break; 12694 12695 } 12696 } finally {dbg.exitSubRule(154);} 12697 12698 dbg.location(1195,9); 12699 match(input,RBRACE,FOLLOW_RBRACE_in_arrayInitializer7208); if (state.failed) return ; 12700 12701 } 12702 12703 } 12704 catch (RecognitionException re) { 12705 reportError(re); 12706 recover(input,re); 12707 } 12708 finally { 12709 if ( state.backtracking>0 ) { memoize(input, 96, arrayInitializer_StartIndex); } 12710 } 12711 dbg.location(1196, 5); 12712 12713 } 12714 finally { 12715 dbg.exitRule(getGrammarFileName(), "arrayInitializer"); 12716 decRuleLevel(); 12717 if ( getRuleLevel()==0 ) {dbg.terminate();} 12718 } 12719 12720 return ; 12721 } 12722 // $ANTLR end "arrayInitializer" 12723 12724 12725 // $ANTLR start "createdName" 12726 // src/com/google/doclava/parser/Java.g:1199:1: createdName : ( classOrInterfaceType | primitiveType ); createdName()12727 public final void createdName() throws RecognitionException { 12728 int createdName_StartIndex = input.index(); 12729 try { dbg.enterRule(getGrammarFileName(), "createdName"); 12730 if ( getRuleLevel()==0 ) {dbg.commence();} 12731 incRuleLevel(); 12732 dbg.location(1199, 1); 12733 12734 try { 12735 if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; } 12736 // src/com/google/doclava/parser/Java.g:1200:5: ( classOrInterfaceType | primitiveType ) 12737 int alt155=2; 12738 try { dbg.enterDecision(155, decisionCanBacktrack[155]); 12739 12740 int LA155_0 = input.LA(1); 12741 12742 if ( (LA155_0==IDENTIFIER) ) { 12743 alt155=1; 12744 } 12745 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) ) { 12746 alt155=2; 12747 } 12748 else { 12749 if (state.backtracking>0) {state.failed=true; return ;} 12750 NoViableAltException nvae = 12751 new NoViableAltException("", 155, 0, input); 12752 12753 dbg.recognitionException(nvae); 12754 throw nvae; 12755 } 12756 } finally {dbg.exitDecision(155);} 12757 12758 switch (alt155) { 12759 case 1 : 12760 dbg.enterAlt(1); 12761 12762 // src/com/google/doclava/parser/Java.g:1200:9: classOrInterfaceType 12763 { 12764 dbg.location(1200,9); 12765 pushFollow(FOLLOW_classOrInterfaceType_in_createdName7241); 12766 classOrInterfaceType(); 12767 12768 state._fsp--; 12769 if (state.failed) return ; 12770 12771 } 12772 break; 12773 case 2 : 12774 dbg.enterAlt(2); 12775 12776 // src/com/google/doclava/parser/Java.g:1201:9: primitiveType 12777 { 12778 dbg.location(1201,9); 12779 pushFollow(FOLLOW_primitiveType_in_createdName7251); 12780 primitiveType(); 12781 12782 state._fsp--; 12783 if (state.failed) return ; 12784 12785 } 12786 break; 12787 12788 } 12789 } 12790 catch (RecognitionException re) { 12791 reportError(re); 12792 recover(input,re); 12793 } 12794 finally { 12795 if ( state.backtracking>0 ) { memoize(input, 97, createdName_StartIndex); } 12796 } 12797 dbg.location(1202, 5); 12798 12799 } 12800 finally { 12801 dbg.exitRule(getGrammarFileName(), "createdName"); 12802 decRuleLevel(); 12803 if ( getRuleLevel()==0 ) {dbg.terminate();} 12804 } 12805 12806 return ; 12807 } 12808 // $ANTLR end "createdName" 12809 12810 12811 // $ANTLR start "innerCreator" 12812 // src/com/google/doclava/parser/Java.g:1204:1: innerCreator : '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ; innerCreator()12813 public final void innerCreator() throws RecognitionException { 12814 int innerCreator_StartIndex = input.index(); 12815 try { dbg.enterRule(getGrammarFileName(), "innerCreator"); 12816 if ( getRuleLevel()==0 ) {dbg.commence();} 12817 incRuleLevel(); 12818 dbg.location(1204, 1); 12819 12820 try { 12821 if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; } 12822 // src/com/google/doclava/parser/Java.g:1205:5: ( '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ) 12823 dbg.enterAlt(1); 12824 12825 // src/com/google/doclava/parser/Java.g:1205:9: '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest 12826 { 12827 dbg.location(1205,9); 12828 match(input,DOT,FOLLOW_DOT_in_innerCreator7270); if (state.failed) return ; 12829 dbg.location(1205,13); 12830 match(input,NEW,FOLLOW_NEW_in_innerCreator7272); if (state.failed) return ; 12831 dbg.location(1206,9); 12832 // src/com/google/doclava/parser/Java.g:1206:9: ( nonWildcardTypeArguments )? 12833 int alt156=2; 12834 try { dbg.enterSubRule(156); 12835 try { dbg.enterDecision(156, decisionCanBacktrack[156]); 12836 12837 int LA156_0 = input.LA(1); 12838 12839 if ( (LA156_0==LT) ) { 12840 alt156=1; 12841 } 12842 } finally {dbg.exitDecision(156);} 12843 12844 switch (alt156) { 12845 case 1 : 12846 dbg.enterAlt(1); 12847 12848 // src/com/google/doclava/parser/Java.g:1206:10: nonWildcardTypeArguments 12849 { 12850 dbg.location(1206,10); 12851 pushFollow(FOLLOW_nonWildcardTypeArguments_in_innerCreator7283); 12852 nonWildcardTypeArguments(); 12853 12854 state._fsp--; 12855 if (state.failed) return ; 12856 12857 } 12858 break; 12859 12860 } 12861 } finally {dbg.exitSubRule(156);} 12862 12863 dbg.location(1208,9); 12864 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_innerCreator7304); if (state.failed) return ; 12865 dbg.location(1209,9); 12866 // src/com/google/doclava/parser/Java.g:1209:9: ( typeArguments )? 12867 int alt157=2; 12868 try { dbg.enterSubRule(157); 12869 try { dbg.enterDecision(157, decisionCanBacktrack[157]); 12870 12871 int LA157_0 = input.LA(1); 12872 12873 if ( (LA157_0==LT) ) { 12874 alt157=1; 12875 } 12876 } finally {dbg.exitDecision(157);} 12877 12878 switch (alt157) { 12879 case 1 : 12880 dbg.enterAlt(1); 12881 12882 // src/com/google/doclava/parser/Java.g:1209:10: typeArguments 12883 { 12884 dbg.location(1209,10); 12885 pushFollow(FOLLOW_typeArguments_in_innerCreator7315); 12886 typeArguments(); 12887 12888 state._fsp--; 12889 if (state.failed) return ; 12890 12891 } 12892 break; 12893 12894 } 12895 } finally {dbg.exitSubRule(157);} 12896 12897 dbg.location(1211,9); 12898 pushFollow(FOLLOW_classCreatorRest_in_innerCreator7336); 12899 classCreatorRest(); 12900 12901 state._fsp--; 12902 if (state.failed) return ; 12903 12904 } 12905 12906 } 12907 catch (RecognitionException re) { 12908 reportError(re); 12909 recover(input,re); 12910 } 12911 finally { 12912 if ( state.backtracking>0 ) { memoize(input, 98, innerCreator_StartIndex); } 12913 } 12914 dbg.location(1212, 5); 12915 12916 } 12917 finally { 12918 dbg.exitRule(getGrammarFileName(), "innerCreator"); 12919 decRuleLevel(); 12920 if ( getRuleLevel()==0 ) {dbg.terminate();} 12921 } 12922 12923 return ; 12924 } 12925 // $ANTLR end "innerCreator" 12926 12927 12928 // $ANTLR start "classCreatorRest" 12929 // src/com/google/doclava/parser/Java.g:1215:1: classCreatorRest : arguments ( classBody )? ; classCreatorRest()12930 public final void classCreatorRest() throws RecognitionException { 12931 int classCreatorRest_StartIndex = input.index(); 12932 try { dbg.enterRule(getGrammarFileName(), "classCreatorRest"); 12933 if ( getRuleLevel()==0 ) {dbg.commence();} 12934 incRuleLevel(); 12935 dbg.location(1215, 1); 12936 12937 try { 12938 if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; } 12939 // src/com/google/doclava/parser/Java.g:1216:5: ( arguments ( classBody )? ) 12940 dbg.enterAlt(1); 12941 12942 // src/com/google/doclava/parser/Java.g:1216:9: arguments ( classBody )? 12943 { 12944 dbg.location(1216,9); 12945 pushFollow(FOLLOW_arguments_in_classCreatorRest7356); 12946 arguments(); 12947 12948 state._fsp--; 12949 if (state.failed) return ; 12950 dbg.location(1217,9); 12951 // src/com/google/doclava/parser/Java.g:1217:9: ( classBody )? 12952 int alt158=2; 12953 try { dbg.enterSubRule(158); 12954 try { dbg.enterDecision(158, decisionCanBacktrack[158]); 12955 12956 int LA158_0 = input.LA(1); 12957 12958 if ( (LA158_0==LBRACE) ) { 12959 alt158=1; 12960 } 12961 } finally {dbg.exitDecision(158);} 12962 12963 switch (alt158) { 12964 case 1 : 12965 dbg.enterAlt(1); 12966 12967 // src/com/google/doclava/parser/Java.g:1217:10: classBody 12968 { 12969 dbg.location(1217,10); 12970 pushFollow(FOLLOW_classBody_in_classCreatorRest7367); 12971 classBody(); 12972 12973 state._fsp--; 12974 if (state.failed) return ; 12975 12976 } 12977 break; 12978 12979 } 12980 } finally {dbg.exitSubRule(158);} 12981 12982 12983 } 12984 12985 } 12986 catch (RecognitionException re) { 12987 reportError(re); 12988 recover(input,re); 12989 } 12990 finally { 12991 if ( state.backtracking>0 ) { memoize(input, 99, classCreatorRest_StartIndex); } 12992 } 12993 dbg.location(1219, 5); 12994 12995 } 12996 finally { 12997 dbg.exitRule(getGrammarFileName(), "classCreatorRest"); 12998 decRuleLevel(); 12999 if ( getRuleLevel()==0 ) {dbg.terminate();} 13000 } 13001 13002 return ; 13003 } 13004 // $ANTLR end "classCreatorRest" 13005 13006 13007 // $ANTLR start "nonWildcardTypeArguments" 13008 // src/com/google/doclava/parser/Java.g:1222:1: nonWildcardTypeArguments : '<' typeList '>' ; nonWildcardTypeArguments()13009 public final void nonWildcardTypeArguments() throws RecognitionException { 13010 int nonWildcardTypeArguments_StartIndex = input.index(); 13011 try { dbg.enterRule(getGrammarFileName(), "nonWildcardTypeArguments"); 13012 if ( getRuleLevel()==0 ) {dbg.commence();} 13013 incRuleLevel(); 13014 dbg.location(1222, 1); 13015 13016 try { 13017 if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; } 13018 // src/com/google/doclava/parser/Java.g:1223:5: ( '<' typeList '>' ) 13019 dbg.enterAlt(1); 13020 13021 // src/com/google/doclava/parser/Java.g:1223:9: '<' typeList '>' 13022 { 13023 dbg.location(1223,9); 13024 match(input,LT,FOLLOW_LT_in_nonWildcardTypeArguments7398); if (state.failed) return ; 13025 dbg.location(1223,13); 13026 pushFollow(FOLLOW_typeList_in_nonWildcardTypeArguments7400); 13027 typeList(); 13028 13029 state._fsp--; 13030 if (state.failed) return ; 13031 dbg.location(1224,9); 13032 match(input,GT,FOLLOW_GT_in_nonWildcardTypeArguments7410); if (state.failed) return ; 13033 13034 } 13035 13036 } 13037 catch (RecognitionException re) { 13038 reportError(re); 13039 recover(input,re); 13040 } 13041 finally { 13042 if ( state.backtracking>0 ) { memoize(input, 100, nonWildcardTypeArguments_StartIndex); } 13043 } 13044 dbg.location(1225, 5); 13045 13046 } 13047 finally { 13048 dbg.exitRule(getGrammarFileName(), "nonWildcardTypeArguments"); 13049 decRuleLevel(); 13050 if ( getRuleLevel()==0 ) {dbg.terminate();} 13051 } 13052 13053 return ; 13054 } 13055 // $ANTLR end "nonWildcardTypeArguments" 13056 13057 13058 // $ANTLR start "arguments" 13059 // src/com/google/doclava/parser/Java.g:1227:1: arguments : '(' ( expressionList )? ')' ; arguments()13060 public final void arguments() throws RecognitionException { 13061 int arguments_StartIndex = input.index(); 13062 try { dbg.enterRule(getGrammarFileName(), "arguments"); 13063 if ( getRuleLevel()==0 ) {dbg.commence();} 13064 incRuleLevel(); 13065 dbg.location(1227, 1); 13066 13067 try { 13068 if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; } 13069 // src/com/google/doclava/parser/Java.g:1228:5: ( '(' ( expressionList )? ')' ) 13070 dbg.enterAlt(1); 13071 13072 // src/com/google/doclava/parser/Java.g:1228:9: '(' ( expressionList )? ')' 13073 { 13074 dbg.location(1228,9); 13075 match(input,LPAREN,FOLLOW_LPAREN_in_arguments7429); if (state.failed) return ; 13076 dbg.location(1228,13); 13077 // src/com/google/doclava/parser/Java.g:1228:13: ( expressionList )? 13078 int alt159=2; 13079 try { dbg.enterSubRule(159); 13080 try { dbg.enterDecision(159, decisionCanBacktrack[159]); 13081 13082 int LA159_0 = input.LA(1); 13083 13084 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)) ) { 13085 alt159=1; 13086 } 13087 } finally {dbg.exitDecision(159);} 13088 13089 switch (alt159) { 13090 case 1 : 13091 dbg.enterAlt(1); 13092 13093 // src/com/google/doclava/parser/Java.g:1228:14: expressionList 13094 { 13095 dbg.location(1228,14); 13096 pushFollow(FOLLOW_expressionList_in_arguments7432); 13097 expressionList(); 13098 13099 state._fsp--; 13100 if (state.failed) return ; 13101 13102 } 13103 break; 13104 13105 } 13106 } finally {dbg.exitSubRule(159);} 13107 13108 dbg.location(1229,12); 13109 match(input,RPAREN,FOLLOW_RPAREN_in_arguments7445); if (state.failed) return ; 13110 13111 } 13112 13113 } 13114 catch (RecognitionException re) { 13115 reportError(re); 13116 recover(input,re); 13117 } 13118 finally { 13119 if ( state.backtracking>0 ) { memoize(input, 101, arguments_StartIndex); } 13120 } 13121 dbg.location(1230, 5); 13122 13123 } 13124 finally { 13125 dbg.exitRule(getGrammarFileName(), "arguments"); 13126 decRuleLevel(); 13127 if ( getRuleLevel()==0 ) {dbg.terminate();} 13128 } 13129 13130 return ; 13131 } 13132 // $ANTLR end "arguments" 13133 13134 13135 // $ANTLR start "literal" 13136 // src/com/google/doclava/parser/Java.g:1232:1: literal : ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL ); literal()13137 public final void literal() throws RecognitionException { 13138 int literal_StartIndex = input.index(); 13139 try { dbg.enterRule(getGrammarFileName(), "literal"); 13140 if ( getRuleLevel()==0 ) {dbg.commence();} 13141 incRuleLevel(); 13142 dbg.location(1232, 1); 13143 13144 try { 13145 if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; } 13146 // src/com/google/doclava/parser/Java.g:1233:5: ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL ) 13147 dbg.enterAlt(1); 13148 13149 // src/com/google/doclava/parser/Java.g: 13150 { 13151 dbg.location(1233,5); 13152 if ( (input.LA(1)>=INTLITERAL && input.LA(1)<=NULL) ) { 13153 input.consume(); 13154 state.errorRecovery=false;state.failed=false; 13155 } 13156 else { 13157 if (state.backtracking>0) {state.failed=true; return ;} 13158 MismatchedSetException mse = new MismatchedSetException(null,input); 13159 dbg.recognitionException(mse); 13160 throw mse; 13161 } 13162 13163 13164 } 13165 13166 } 13167 catch (RecognitionException re) { 13168 reportError(re); 13169 recover(input,re); 13170 } 13171 finally { 13172 if ( state.backtracking>0 ) { memoize(input, 102, literal_StartIndex); } 13173 } 13174 dbg.location(1242, 5); 13175 13176 } 13177 finally { 13178 dbg.exitRule(getGrammarFileName(), "literal"); 13179 decRuleLevel(); 13180 if ( getRuleLevel()==0 ) {dbg.terminate();} 13181 } 13182 13183 return ; 13184 } 13185 // $ANTLR end "literal" 13186 13187 13188 // $ANTLR start "classHeader" 13189 // src/com/google/doclava/parser/Java.g:1244:1: classHeader : modifiers 'class' IDENTIFIER ; classHeader()13190 public final void classHeader() throws RecognitionException { 13191 int classHeader_StartIndex = input.index(); 13192 try { dbg.enterRule(getGrammarFileName(), "classHeader"); 13193 if ( getRuleLevel()==0 ) {dbg.commence();} 13194 incRuleLevel(); 13195 dbg.location(1244, 1); 13196 13197 try { 13198 if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; } 13199 // src/com/google/doclava/parser/Java.g:1249:5: ( modifiers 'class' IDENTIFIER ) 13200 dbg.enterAlt(1); 13201 13202 // src/com/google/doclava/parser/Java.g:1249:9: modifiers 'class' IDENTIFIER 13203 { 13204 dbg.location(1249,9); 13205 pushFollow(FOLLOW_modifiers_in_classHeader7566); 13206 modifiers(); 13207 13208 state._fsp--; 13209 if (state.failed) return ; 13210 dbg.location(1249,19); 13211 match(input,CLASS,FOLLOW_CLASS_in_classHeader7568); if (state.failed) return ; 13212 dbg.location(1249,27); 13213 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classHeader7570); if (state.failed) return ; 13214 13215 } 13216 13217 } 13218 catch (RecognitionException re) { 13219 reportError(re); 13220 recover(input,re); 13221 } 13222 finally { 13223 if ( state.backtracking>0 ) { memoize(input, 103, classHeader_StartIndex); } 13224 } 13225 dbg.location(1250, 5); 13226 13227 } 13228 finally { 13229 dbg.exitRule(getGrammarFileName(), "classHeader"); 13230 decRuleLevel(); 13231 if ( getRuleLevel()==0 ) {dbg.terminate();} 13232 } 13233 13234 return ; 13235 } 13236 // $ANTLR end "classHeader" 13237 13238 13239 // $ANTLR start "enumHeader" 13240 // src/com/google/doclava/parser/Java.g:1252:1: enumHeader : modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ; enumHeader()13241 public final void enumHeader() throws RecognitionException { 13242 int enumHeader_StartIndex = input.index(); 13243 try { dbg.enterRule(getGrammarFileName(), "enumHeader"); 13244 if ( getRuleLevel()==0 ) {dbg.commence();} 13245 incRuleLevel(); 13246 dbg.location(1252, 1); 13247 13248 try { 13249 if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; } 13250 // src/com/google/doclava/parser/Java.g:1253:5: ( modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ) 13251 dbg.enterAlt(1); 13252 13253 // src/com/google/doclava/parser/Java.g:1253:9: modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER 13254 { 13255 dbg.location(1253,9); 13256 pushFollow(FOLLOW_modifiers_in_enumHeader7589); 13257 modifiers(); 13258 13259 state._fsp--; 13260 if (state.failed) return ; 13261 dbg.location(1253,19); 13262 if ( input.LA(1)==IDENTIFIER||input.LA(1)==ENUM ) { 13263 input.consume(); 13264 state.errorRecovery=false;state.failed=false; 13265 } 13266 else { 13267 if (state.backtracking>0) {state.failed=true; return ;} 13268 MismatchedSetException mse = new MismatchedSetException(null,input); 13269 dbg.recognitionException(mse); 13270 throw mse; 13271 } 13272 13273 dbg.location(1253,39); 13274 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader7597); if (state.failed) return ; 13275 13276 } 13277 13278 } 13279 catch (RecognitionException re) { 13280 reportError(re); 13281 recover(input,re); 13282 } 13283 finally { 13284 if ( state.backtracking>0 ) { memoize(input, 104, enumHeader_StartIndex); } 13285 } 13286 dbg.location(1254, 5); 13287 13288 } 13289 finally { 13290 dbg.exitRule(getGrammarFileName(), "enumHeader"); 13291 decRuleLevel(); 13292 if ( getRuleLevel()==0 ) {dbg.terminate();} 13293 } 13294 13295 return ; 13296 } 13297 // $ANTLR end "enumHeader" 13298 13299 13300 // $ANTLR start "interfaceHeader" 13301 // src/com/google/doclava/parser/Java.g:1256:1: interfaceHeader : modifiers 'interface' IDENTIFIER ; interfaceHeader()13302 public final void interfaceHeader() throws RecognitionException { 13303 int interfaceHeader_StartIndex = input.index(); 13304 try { dbg.enterRule(getGrammarFileName(), "interfaceHeader"); 13305 if ( getRuleLevel()==0 ) {dbg.commence();} 13306 incRuleLevel(); 13307 dbg.location(1256, 1); 13308 13309 try { 13310 if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; } 13311 // src/com/google/doclava/parser/Java.g:1257:5: ( modifiers 'interface' IDENTIFIER ) 13312 dbg.enterAlt(1); 13313 13314 // src/com/google/doclava/parser/Java.g:1257:9: modifiers 'interface' IDENTIFIER 13315 { 13316 dbg.location(1257,9); 13317 pushFollow(FOLLOW_modifiers_in_interfaceHeader7616); 13318 modifiers(); 13319 13320 state._fsp--; 13321 if (state.failed) return ; 13322 dbg.location(1257,19); 13323 match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceHeader7618); if (state.failed) return ; 13324 dbg.location(1257,31); 13325 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceHeader7620); if (state.failed) return ; 13326 13327 } 13328 13329 } 13330 catch (RecognitionException re) { 13331 reportError(re); 13332 recover(input,re); 13333 } 13334 finally { 13335 if ( state.backtracking>0 ) { memoize(input, 105, interfaceHeader_StartIndex); } 13336 } 13337 dbg.location(1258, 5); 13338 13339 } 13340 finally { 13341 dbg.exitRule(getGrammarFileName(), "interfaceHeader"); 13342 decRuleLevel(); 13343 if ( getRuleLevel()==0 ) {dbg.terminate();} 13344 } 13345 13346 return ; 13347 } 13348 // $ANTLR end "interfaceHeader" 13349 13350 13351 // $ANTLR start "annotationHeader" 13352 // src/com/google/doclava/parser/Java.g:1260:1: annotationHeader : modifiers '@' 'interface' IDENTIFIER ; annotationHeader()13353 public final void annotationHeader() throws RecognitionException { 13354 int annotationHeader_StartIndex = input.index(); 13355 try { dbg.enterRule(getGrammarFileName(), "annotationHeader"); 13356 if ( getRuleLevel()==0 ) {dbg.commence();} 13357 incRuleLevel(); 13358 dbg.location(1260, 1); 13359 13360 try { 13361 if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return ; } 13362 // src/com/google/doclava/parser/Java.g:1261:5: ( modifiers '@' 'interface' IDENTIFIER ) 13363 dbg.enterAlt(1); 13364 13365 // src/com/google/doclava/parser/Java.g:1261:9: modifiers '@' 'interface' IDENTIFIER 13366 { 13367 dbg.location(1261,9); 13368 pushFollow(FOLLOW_modifiers_in_annotationHeader7639); 13369 modifiers(); 13370 13371 state._fsp--; 13372 if (state.failed) return ; 13373 dbg.location(1261,19); 13374 match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationHeader7641); if (state.failed) return ; 13375 dbg.location(1261,23); 13376 match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationHeader7643); if (state.failed) return ; 13377 dbg.location(1261,35); 13378 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationHeader7645); if (state.failed) return ; 13379 13380 } 13381 13382 } 13383 catch (RecognitionException re) { 13384 reportError(re); 13385 recover(input,re); 13386 } 13387 finally { 13388 if ( state.backtracking>0 ) { memoize(input, 106, annotationHeader_StartIndex); } 13389 } 13390 dbg.location(1262, 5); 13391 13392 } 13393 finally { 13394 dbg.exitRule(getGrammarFileName(), "annotationHeader"); 13395 decRuleLevel(); 13396 if ( getRuleLevel()==0 ) {dbg.terminate();} 13397 } 13398 13399 return ; 13400 } 13401 // $ANTLR end "annotationHeader" 13402 13403 13404 // $ANTLR start "typeHeader" 13405 // src/com/google/doclava/parser/Java.g:1264:1: typeHeader : modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ; typeHeader()13406 public final void typeHeader() throws RecognitionException { 13407 int typeHeader_StartIndex = input.index(); 13408 try { dbg.enterRule(getGrammarFileName(), "typeHeader"); 13409 if ( getRuleLevel()==0 ) {dbg.commence();} 13410 incRuleLevel(); 13411 dbg.location(1264, 1); 13412 13413 try { 13414 if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return ; } 13415 // src/com/google/doclava/parser/Java.g:1265:5: ( modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ) 13416 dbg.enterAlt(1); 13417 13418 // src/com/google/doclava/parser/Java.g:1265:9: modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER 13419 { 13420 dbg.location(1265,9); 13421 pushFollow(FOLLOW_modifiers_in_typeHeader7664); 13422 modifiers(); 13423 13424 state._fsp--; 13425 if (state.failed) return ; 13426 dbg.location(1265,19); 13427 // src/com/google/doclava/parser/Java.g:1265:19: ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) 13428 int alt161=3; 13429 try { dbg.enterSubRule(161); 13430 try { dbg.enterDecision(161, decisionCanBacktrack[161]); 13431 13432 switch ( input.LA(1) ) { 13433 case CLASS: 13434 { 13435 alt161=1; 13436 } 13437 break; 13438 case ENUM: 13439 { 13440 alt161=2; 13441 } 13442 break; 13443 case INTERFACE: 13444 case MONKEYS_AT: 13445 { 13446 alt161=3; 13447 } 13448 break; 13449 default: 13450 if (state.backtracking>0) {state.failed=true; return ;} 13451 NoViableAltException nvae = 13452 new NoViableAltException("", 161, 0, input); 13453 13454 dbg.recognitionException(nvae); 13455 throw nvae; 13456 } 13457 13458 } finally {dbg.exitDecision(161);} 13459 13460 switch (alt161) { 13461 case 1 : 13462 dbg.enterAlt(1); 13463 13464 // src/com/google/doclava/parser/Java.g:1265:20: 'class' 13465 { 13466 dbg.location(1265,20); 13467 match(input,CLASS,FOLLOW_CLASS_in_typeHeader7667); if (state.failed) return ; 13468 13469 } 13470 break; 13471 case 2 : 13472 dbg.enterAlt(2); 13473 13474 // src/com/google/doclava/parser/Java.g:1265:28: 'enum' 13475 { 13476 dbg.location(1265,28); 13477 match(input,ENUM,FOLLOW_ENUM_in_typeHeader7669); if (state.failed) return ; 13478 13479 } 13480 break; 13481 case 3 : 13482 dbg.enterAlt(3); 13483 13484 // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' ) 13485 { 13486 dbg.location(1265,35); 13487 // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' ) 13488 dbg.enterAlt(1); 13489 13490 // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )? 'interface' 13491 { 13492 dbg.location(1265,36); 13493 // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )? 13494 int alt160=2; 13495 try { dbg.enterSubRule(160); 13496 try { dbg.enterDecision(160, decisionCanBacktrack[160]); 13497 13498 int LA160_0 = input.LA(1); 13499 13500 if ( (LA160_0==MONKEYS_AT) ) { 13501 alt160=1; 13502 } 13503 } finally {dbg.exitDecision(160);} 13504 13505 switch (alt160) { 13506 case 1 : 13507 dbg.enterAlt(1); 13508 13509 // src/com/google/doclava/parser/Java.g:0:0: '@' 13510 { 13511 dbg.location(1265,36); 13512 match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_typeHeader7672); if (state.failed) return ; 13513 13514 } 13515 break; 13516 13517 } 13518 } finally {dbg.exitSubRule(160);} 13519 13520 dbg.location(1265,42); 13521 match(input,INTERFACE,FOLLOW_INTERFACE_in_typeHeader7676); if (state.failed) return ; 13522 13523 } 13524 13525 13526 } 13527 break; 13528 13529 } 13530 } finally {dbg.exitSubRule(161);} 13531 13532 dbg.location(1265,56); 13533 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeHeader7680); if (state.failed) return ; 13534 13535 } 13536 13537 } 13538 catch (RecognitionException re) { 13539 reportError(re); 13540 recover(input,re); 13541 } 13542 finally { 13543 if ( state.backtracking>0 ) { memoize(input, 107, typeHeader_StartIndex); } 13544 } 13545 dbg.location(1266, 5); 13546 13547 } 13548 finally { 13549 dbg.exitRule(getGrammarFileName(), "typeHeader"); 13550 decRuleLevel(); 13551 if ( getRuleLevel()==0 ) {dbg.terminate();} 13552 } 13553 13554 return ; 13555 } 13556 // $ANTLR end "typeHeader" 13557 13558 13559 // $ANTLR start "methodHeader" 13560 // src/com/google/doclava/parser/Java.g:1268:1: methodHeader : modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ; methodHeader()13561 public final void methodHeader() throws RecognitionException { 13562 int methodHeader_StartIndex = input.index(); 13563 try { dbg.enterRule(getGrammarFileName(), "methodHeader"); 13564 if ( getRuleLevel()==0 ) {dbg.commence();} 13565 incRuleLevel(); 13566 dbg.location(1268, 1); 13567 13568 try { 13569 if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return ; } 13570 // src/com/google/doclava/parser/Java.g:1269:5: ( modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ) 13571 dbg.enterAlt(1); 13572 13573 // src/com/google/doclava/parser/Java.g:1269:9: modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' 13574 { 13575 dbg.location(1269,9); 13576 pushFollow(FOLLOW_modifiers_in_methodHeader7699); 13577 modifiers(); 13578 13579 state._fsp--; 13580 if (state.failed) return ; 13581 dbg.location(1269,19); 13582 // src/com/google/doclava/parser/Java.g:1269:19: ( typeParameters )? 13583 int alt162=2; 13584 try { dbg.enterSubRule(162); 13585 try { dbg.enterDecision(162, decisionCanBacktrack[162]); 13586 13587 int LA162_0 = input.LA(1); 13588 13589 if ( (LA162_0==LT) ) { 13590 alt162=1; 13591 } 13592 } finally {dbg.exitDecision(162);} 13593 13594 switch (alt162) { 13595 case 1 : 13596 dbg.enterAlt(1); 13597 13598 // src/com/google/doclava/parser/Java.g:0:0: typeParameters 13599 { 13600 dbg.location(1269,19); 13601 pushFollow(FOLLOW_typeParameters_in_methodHeader7701); 13602 typeParameters(); 13603 13604 state._fsp--; 13605 if (state.failed) return ; 13606 13607 } 13608 break; 13609 13610 } 13611 } finally {dbg.exitSubRule(162);} 13612 13613 dbg.location(1269,35); 13614 // src/com/google/doclava/parser/Java.g:1269:35: ( type | 'void' )? 13615 int alt163=3; 13616 try { dbg.enterSubRule(163); 13617 try { dbg.enterDecision(163, decisionCanBacktrack[163]); 13618 13619 switch ( input.LA(1) ) { 13620 case IDENTIFIER: 13621 { 13622 int LA163_1 = input.LA(2); 13623 13624 if ( (LA163_1==IDENTIFIER||LA163_1==LBRACKET||LA163_1==DOT||LA163_1==LT) ) { 13625 alt163=1; 13626 } 13627 } 13628 break; 13629 case BOOLEAN: 13630 case BYTE: 13631 case CHAR: 13632 case DOUBLE: 13633 case FLOAT: 13634 case INT: 13635 case LONG: 13636 case SHORT: 13637 { 13638 alt163=1; 13639 } 13640 break; 13641 case VOID: 13642 { 13643 alt163=2; 13644 } 13645 break; 13646 } 13647 13648 } finally {dbg.exitDecision(163);} 13649 13650 switch (alt163) { 13651 case 1 : 13652 dbg.enterAlt(1); 13653 13654 // src/com/google/doclava/parser/Java.g:1269:36: type 13655 { 13656 dbg.location(1269,36); 13657 pushFollow(FOLLOW_type_in_methodHeader7705); 13658 type(); 13659 13660 state._fsp--; 13661 if (state.failed) return ; 13662 13663 } 13664 break; 13665 case 2 : 13666 dbg.enterAlt(2); 13667 13668 // src/com/google/doclava/parser/Java.g:1269:41: 'void' 13669 { 13670 dbg.location(1269,41); 13671 match(input,VOID,FOLLOW_VOID_in_methodHeader7707); if (state.failed) return ; 13672 13673 } 13674 break; 13675 13676 } 13677 } finally {dbg.exitSubRule(163);} 13678 13679 dbg.location(1269,50); 13680 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodHeader7711); if (state.failed) return ; 13681 dbg.location(1269,61); 13682 match(input,LPAREN,FOLLOW_LPAREN_in_methodHeader7713); if (state.failed) return ; 13683 13684 } 13685 13686 } 13687 catch (RecognitionException re) { 13688 reportError(re); 13689 recover(input,re); 13690 } 13691 finally { 13692 if ( state.backtracking>0 ) { memoize(input, 108, methodHeader_StartIndex); } 13693 } 13694 dbg.location(1270, 5); 13695 13696 } 13697 finally { 13698 dbg.exitRule(getGrammarFileName(), "methodHeader"); 13699 decRuleLevel(); 13700 if ( getRuleLevel()==0 ) {dbg.terminate();} 13701 } 13702 13703 return ; 13704 } 13705 // $ANTLR end "methodHeader" 13706 13707 13708 // $ANTLR start "fieldHeader" 13709 // src/com/google/doclava/parser/Java.g:1272:1: fieldHeader : modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ; fieldHeader()13710 public final void fieldHeader() throws RecognitionException { 13711 int fieldHeader_StartIndex = input.index(); 13712 try { dbg.enterRule(getGrammarFileName(), "fieldHeader"); 13713 if ( getRuleLevel()==0 ) {dbg.commence();} 13714 incRuleLevel(); 13715 dbg.location(1272, 1); 13716 13717 try { 13718 if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return ; } 13719 // src/com/google/doclava/parser/Java.g:1273:5: ( modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ) 13720 dbg.enterAlt(1); 13721 13722 // src/com/google/doclava/parser/Java.g:1273:9: modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) 13723 { 13724 dbg.location(1273,9); 13725 pushFollow(FOLLOW_modifiers_in_fieldHeader7732); 13726 modifiers(); 13727 13728 state._fsp--; 13729 if (state.failed) return ; 13730 dbg.location(1273,19); 13731 pushFollow(FOLLOW_type_in_fieldHeader7734); 13732 type(); 13733 13734 state._fsp--; 13735 if (state.failed) return ; 13736 dbg.location(1273,24); 13737 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_fieldHeader7736); if (state.failed) return ; 13738 dbg.location(1273,35); 13739 // src/com/google/doclava/parser/Java.g:1273:35: ( '[' ']' )* 13740 try { dbg.enterSubRule(164); 13741 13742 loop164: 13743 do { 13744 int alt164=2; 13745 try { dbg.enterDecision(164, decisionCanBacktrack[164]); 13746 13747 int LA164_0 = input.LA(1); 13748 13749 if ( (LA164_0==LBRACKET) ) { 13750 alt164=1; 13751 } 13752 13753 13754 } finally {dbg.exitDecision(164);} 13755 13756 switch (alt164) { 13757 case 1 : 13758 dbg.enterAlt(1); 13759 13760 // src/com/google/doclava/parser/Java.g:1273:36: '[' ']' 13761 { 13762 dbg.location(1273,36); 13763 match(input,LBRACKET,FOLLOW_LBRACKET_in_fieldHeader7739); if (state.failed) return ; 13764 dbg.location(1273,39); 13765 match(input,RBRACKET,FOLLOW_RBRACKET_in_fieldHeader7740); if (state.failed) return ; 13766 13767 } 13768 break; 13769 13770 default : 13771 break loop164; 13772 } 13773 } while (true); 13774 } finally {dbg.exitSubRule(164);} 13775 13776 dbg.location(1273,45); 13777 if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) { 13778 input.consume(); 13779 state.errorRecovery=false;state.failed=false; 13780 } 13781 else { 13782 if (state.backtracking>0) {state.failed=true; return ;} 13783 MismatchedSetException mse = new MismatchedSetException(null,input); 13784 dbg.recognitionException(mse); 13785 throw mse; 13786 } 13787 13788 13789 } 13790 13791 } 13792 catch (RecognitionException re) { 13793 reportError(re); 13794 recover(input,re); 13795 } 13796 finally { 13797 if ( state.backtracking>0 ) { memoize(input, 109, fieldHeader_StartIndex); } 13798 } 13799 dbg.location(1274, 5); 13800 13801 } 13802 finally { 13803 dbg.exitRule(getGrammarFileName(), "fieldHeader"); 13804 decRuleLevel(); 13805 if ( getRuleLevel()==0 ) {dbg.terminate();} 13806 } 13807 13808 return ; 13809 } 13810 // $ANTLR end "fieldHeader" 13811 13812 13813 // $ANTLR start "localVariableHeader" 13814 // src/com/google/doclava/parser/Java.g:1276:1: localVariableHeader : variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ; localVariableHeader()13815 public final void localVariableHeader() throws RecognitionException { 13816 int localVariableHeader_StartIndex = input.index(); 13817 try { dbg.enterRule(getGrammarFileName(), "localVariableHeader"); 13818 if ( getRuleLevel()==0 ) {dbg.commence();} 13819 incRuleLevel(); 13820 dbg.location(1276, 1); 13821 13822 try { 13823 if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return ; } 13824 // src/com/google/doclava/parser/Java.g:1277:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ) 13825 dbg.enterAlt(1); 13826 13827 // src/com/google/doclava/parser/Java.g:1277:9: variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) 13828 { 13829 dbg.location(1277,9); 13830 pushFollow(FOLLOW_variableModifiers_in_localVariableHeader7769); 13831 variableModifiers(); 13832 13833 state._fsp--; 13834 if (state.failed) return ; 13835 dbg.location(1277,27); 13836 pushFollow(FOLLOW_type_in_localVariableHeader7771); 13837 type(); 13838 13839 state._fsp--; 13840 if (state.failed) return ; 13841 dbg.location(1277,32); 13842 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_localVariableHeader7773); if (state.failed) return ; 13843 dbg.location(1277,43); 13844 // src/com/google/doclava/parser/Java.g:1277:43: ( '[' ']' )* 13845 try { dbg.enterSubRule(165); 13846 13847 loop165: 13848 do { 13849 int alt165=2; 13850 try { dbg.enterDecision(165, decisionCanBacktrack[165]); 13851 13852 int LA165_0 = input.LA(1); 13853 13854 if ( (LA165_0==LBRACKET) ) { 13855 alt165=1; 13856 } 13857 13858 13859 } finally {dbg.exitDecision(165);} 13860 13861 switch (alt165) { 13862 case 1 : 13863 dbg.enterAlt(1); 13864 13865 // src/com/google/doclava/parser/Java.g:1277:44: '[' ']' 13866 { 13867 dbg.location(1277,44); 13868 match(input,LBRACKET,FOLLOW_LBRACKET_in_localVariableHeader7776); if (state.failed) return ; 13869 dbg.location(1277,47); 13870 match(input,RBRACKET,FOLLOW_RBRACKET_in_localVariableHeader7777); if (state.failed) return ; 13871 13872 } 13873 break; 13874 13875 default : 13876 break loop165; 13877 } 13878 } while (true); 13879 } finally {dbg.exitSubRule(165);} 13880 13881 dbg.location(1277,53); 13882 if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) { 13883 input.consume(); 13884 state.errorRecovery=false;state.failed=false; 13885 } 13886 else { 13887 if (state.backtracking>0) {state.failed=true; return ;} 13888 MismatchedSetException mse = new MismatchedSetException(null,input); 13889 dbg.recognitionException(mse); 13890 throw mse; 13891 } 13892 13893 13894 } 13895 13896 } 13897 catch (RecognitionException re) { 13898 reportError(re); 13899 recover(input,re); 13900 } 13901 finally { 13902 if ( state.backtracking>0 ) { memoize(input, 110, localVariableHeader_StartIndex); } 13903 } 13904 dbg.location(1278, 5); 13905 13906 } 13907 finally { 13908 dbg.exitRule(getGrammarFileName(), "localVariableHeader"); 13909 decRuleLevel(); 13910 if ( getRuleLevel()==0 ) {dbg.terminate();} 13911 } 13912 13913 return ; 13914 } 13915 // $ANTLR end "localVariableHeader" 13916 13917 // $ANTLR start synpred2_Java synpred2_Java_fragment()13918 public final void synpred2_Java_fragment() throws RecognitionException { 13919 // src/com/google/doclava/parser/Java.g:298:13: ( ( annotations )? packageDeclaration ) 13920 dbg.enterAlt(1); 13921 13922 // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration 13923 { 13924 dbg.location(298,13); 13925 // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? 13926 int alt166=2; 13927 try { dbg.enterSubRule(166); 13928 try { dbg.enterDecision(166, decisionCanBacktrack[166]); 13929 13930 int LA166_0 = input.LA(1); 13931 13932 if ( (LA166_0==MONKEYS_AT) ) { 13933 alt166=1; 13934 } 13935 } finally {dbg.exitDecision(166);} 13936 13937 switch (alt166) { 13938 case 1 : 13939 dbg.enterAlt(1); 13940 13941 // src/com/google/doclava/parser/Java.g:298:14: annotations 13942 { 13943 dbg.location(298,14); 13944 pushFollow(FOLLOW_annotations_in_synpred2_Java64); 13945 annotations(); 13946 13947 state._fsp--; 13948 if (state.failed) return ; 13949 13950 } 13951 break; 13952 13953 } 13954 } finally {dbg.exitSubRule(166);} 13955 13956 dbg.location(300,13); 13957 pushFollow(FOLLOW_packageDeclaration_in_synpred2_Java93); 13958 packageDeclaration(); 13959 13960 state._fsp--; 13961 if (state.failed) return ; 13962 13963 } 13964 } 13965 // $ANTLR end synpred2_Java 13966 13967 // $ANTLR start synpred12_Java synpred12_Java_fragment()13968 public final void synpred12_Java_fragment() throws RecognitionException { 13969 // src/com/google/doclava/parser/Java.g:342:10: ( classDeclaration ) 13970 dbg.enterAlt(1); 13971 13972 // src/com/google/doclava/parser/Java.g:342:10: classDeclaration 13973 { 13974 dbg.location(342,10); 13975 pushFollow(FOLLOW_classDeclaration_in_synpred12_Java436); 13976 classDeclaration(); 13977 13978 state._fsp--; 13979 if (state.failed) return ; 13980 13981 } 13982 } 13983 // $ANTLR end synpred12_Java 13984 13985 // $ANTLR start synpred27_Java synpred27_Java_fragment()13986 public final void synpred27_Java_fragment() throws RecognitionException { 13987 // src/com/google/doclava/parser/Java.g:373:9: ( normalClassDeclaration ) 13988 dbg.enterAlt(1); 13989 13990 // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration 13991 { 13992 dbg.location(373,9); 13993 pushFollow(FOLLOW_normalClassDeclaration_in_synpred27_Java659); 13994 normalClassDeclaration(); 13995 13996 state._fsp--; 13997 if (state.failed) return ; 13998 13999 } 14000 } 14001 // $ANTLR end synpred27_Java 14002 14003 // $ANTLR start synpred43_Java synpred43_Java_fragment()14004 public final void synpred43_Java_fragment() throws RecognitionException { 14005 // src/com/google/doclava/parser/Java.g:461:9: ( normalInterfaceDeclaration ) 14006 dbg.enterAlt(1); 14007 14008 // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration 14009 { 14010 dbg.location(461,9); 14011 pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306); 14012 normalInterfaceDeclaration(); 14013 14014 state._fsp--; 14015 if (state.failed) return ; 14016 14017 } 14018 } 14019 // $ANTLR end synpred43_Java 14020 14021 // $ANTLR start synpred52_Java synpred52_Java_fragment()14022 public final void synpred52_Java_fragment() throws RecognitionException { 14023 // src/com/google/doclava/parser/Java.g:503:10: ( fieldDeclaration ) 14024 dbg.enterAlt(1); 14025 14026 // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration 14027 { 14028 dbg.location(503,10); 14029 pushFollow(FOLLOW_fieldDeclaration_in_synpred52_Java1621); 14030 fieldDeclaration(); 14031 14032 state._fsp--; 14033 if (state.failed) return ; 14034 14035 } 14036 } 14037 // $ANTLR end synpred52_Java 14038 14039 // $ANTLR start synpred53_Java synpred53_Java_fragment()14040 public final void synpred53_Java_fragment() throws RecognitionException { 14041 // src/com/google/doclava/parser/Java.g:504:10: ( methodDeclaration ) 14042 dbg.enterAlt(1); 14043 14044 // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration 14045 { 14046 dbg.location(504,10); 14047 pushFollow(FOLLOW_methodDeclaration_in_synpred53_Java1632); 14048 methodDeclaration(); 14049 14050 state._fsp--; 14051 if (state.failed) return ; 14052 14053 } 14054 } 14055 // $ANTLR end synpred53_Java 14056 14057 // $ANTLR start synpred54_Java synpred54_Java_fragment()14058 public final void synpred54_Java_fragment() throws RecognitionException { 14059 // src/com/google/doclava/parser/Java.g:505:10: ( classDeclaration ) 14060 dbg.enterAlt(1); 14061 14062 // src/com/google/doclava/parser/Java.g:505:10: classDeclaration 14063 { 14064 dbg.location(505,10); 14065 pushFollow(FOLLOW_classDeclaration_in_synpred54_Java1643); 14066 classDeclaration(); 14067 14068 state._fsp--; 14069 if (state.failed) return ; 14070 14071 } 14072 } 14073 // $ANTLR end synpred54_Java 14074 14075 // $ANTLR start synpred57_Java synpred57_Java_fragment()14076 public final void synpred57_Java_fragment() throws RecognitionException { 14077 // src/com/google/doclava/parser/Java.g:521:10: ( explicitConstructorInvocation ) 14078 dbg.enterAlt(1); 14079 14080 // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation 14081 { 14082 dbg.location(521,10); 14083 pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778); 14084 explicitConstructorInvocation(); 14085 14086 state._fsp--; 14087 if (state.failed) return ; 14088 14089 } 14090 } 14091 // $ANTLR end synpred57_Java 14092 14093 // $ANTLR start synpred59_Java synpred59_Java_fragment()14094 public final void synpred59_Java_fragment() throws RecognitionException { 14095 // src/com/google/doclava/parser/Java.g:513:10: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' ) 14096 dbg.enterAlt(1); 14097 14098 // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' 14099 { 14100 dbg.location(513,10); 14101 pushFollow(FOLLOW_modifiers_in_synpred59_Java1691); 14102 modifiers(); 14103 14104 state._fsp--; 14105 if (state.failed) return ; 14106 dbg.location(514,9); 14107 // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )? 14108 int alt169=2; 14109 try { dbg.enterSubRule(169); 14110 try { dbg.enterDecision(169, decisionCanBacktrack[169]); 14111 14112 int LA169_0 = input.LA(1); 14113 14114 if ( (LA169_0==LT) ) { 14115 alt169=1; 14116 } 14117 } finally {dbg.exitDecision(169);} 14118 14119 switch (alt169) { 14120 case 1 : 14121 dbg.enterAlt(1); 14122 14123 // src/com/google/doclava/parser/Java.g:514:10: typeParameters 14124 { 14125 dbg.location(514,10); 14126 pushFollow(FOLLOW_typeParameters_in_synpred59_Java1702); 14127 typeParameters(); 14128 14129 state._fsp--; 14130 if (state.failed) return ; 14131 14132 } 14133 break; 14134 14135 } 14136 } finally {dbg.exitSubRule(169);} 14137 14138 dbg.location(516,9); 14139 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred59_Java1723); if (state.failed) return ; 14140 dbg.location(517,9); 14141 pushFollow(FOLLOW_formalParameters_in_synpred59_Java1733); 14142 formalParameters(); 14143 14144 state._fsp--; 14145 if (state.failed) return ; 14146 dbg.location(518,9); 14147 // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )? 14148 int alt170=2; 14149 try { dbg.enterSubRule(170); 14150 try { dbg.enterDecision(170, decisionCanBacktrack[170]); 14151 14152 int LA170_0 = input.LA(1); 14153 14154 if ( (LA170_0==THROWS) ) { 14155 alt170=1; 14156 } 14157 } finally {dbg.exitDecision(170);} 14158 14159 switch (alt170) { 14160 case 1 : 14161 dbg.enterAlt(1); 14162 14163 // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList 14164 { 14165 dbg.location(518,10); 14166 match(input,THROWS,FOLLOW_THROWS_in_synpred59_Java1744); if (state.failed) return ; 14167 dbg.location(518,19); 14168 pushFollow(FOLLOW_qualifiedNameList_in_synpred59_Java1746); 14169 qualifiedNameList(); 14170 14171 state._fsp--; 14172 if (state.failed) return ; 14173 14174 } 14175 break; 14176 14177 } 14178 } finally {dbg.exitSubRule(170);} 14179 14180 dbg.location(520,9); 14181 match(input,LBRACE,FOLLOW_LBRACE_in_synpred59_Java1767); if (state.failed) return ; 14182 dbg.location(521,9); 14183 // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )? 14184 int alt171=2; 14185 try { dbg.enterSubRule(171); 14186 try { dbg.enterDecision(171, decisionCanBacktrack[171]); 14187 14188 try { 14189 isCyclicDecision = true; 14190 alt171 = dfa171.predict(input); 14191 } 14192 catch (NoViableAltException nvae) { 14193 dbg.recognitionException(nvae); 14194 throw nvae; 14195 } 14196 } finally {dbg.exitDecision(171);} 14197 14198 switch (alt171) { 14199 case 1 : 14200 dbg.enterAlt(1); 14201 14202 // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation 14203 { 14204 dbg.location(521,10); 14205 pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778); 14206 explicitConstructorInvocation(); 14207 14208 state._fsp--; 14209 if (state.failed) return ; 14210 14211 } 14212 break; 14213 14214 } 14215 } finally {dbg.exitSubRule(171);} 14216 14217 dbg.location(523,9); 14218 // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )* 14219 try { dbg.enterSubRule(172); 14220 14221 loop172: 14222 do { 14223 int alt172=2; 14224 try { dbg.enterDecision(172, decisionCanBacktrack[172]); 14225 14226 int LA172_0 = input.LA(1); 14227 14228 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) ) { 14229 alt172=1; 14230 } 14231 14232 14233 } finally {dbg.exitDecision(172);} 14234 14235 switch (alt172) { 14236 case 1 : 14237 dbg.enterAlt(1); 14238 14239 // src/com/google/doclava/parser/Java.g:523:10: blockStatement 14240 { 14241 dbg.location(523,10); 14242 pushFollow(FOLLOW_blockStatement_in_synpred59_Java1800); 14243 blockStatement(); 14244 14245 state._fsp--; 14246 if (state.failed) return ; 14247 14248 } 14249 break; 14250 14251 default : 14252 break loop172; 14253 } 14254 } while (true); 14255 } finally {dbg.exitSubRule(172);} 14256 14257 dbg.location(525,9); 14258 match(input,RBRACE,FOLLOW_RBRACE_in_synpred59_Java1821); if (state.failed) return ; 14259 14260 } 14261 } 14262 // $ANTLR end synpred59_Java 14263 14264 // $ANTLR start synpred68_Java synpred68_Java_fragment()14265 public final void synpred68_Java_fragment() throws RecognitionException { 14266 // src/com/google/doclava/parser/Java.g:567:9: ( interfaceFieldDeclaration ) 14267 dbg.enterAlt(1); 14268 14269 // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration 14270 { 14271 dbg.location(567,9); 14272 pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172); 14273 interfaceFieldDeclaration(); 14274 14275 state._fsp--; 14276 if (state.failed) return ; 14277 14278 } 14279 } 14280 // $ANTLR end synpred68_Java 14281 14282 // $ANTLR start synpred69_Java synpred69_Java_fragment()14283 public final void synpred69_Java_fragment() throws RecognitionException { 14284 // src/com/google/doclava/parser/Java.g:568:9: ( interfaceMethodDeclaration ) 14285 dbg.enterAlt(1); 14286 14287 // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration 14288 { 14289 dbg.location(568,9); 14290 pushFollow(FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182); 14291 interfaceMethodDeclaration(); 14292 14293 state._fsp--; 14294 if (state.failed) return ; 14295 14296 } 14297 } 14298 // $ANTLR end synpred69_Java 14299 14300 // $ANTLR start synpred70_Java synpred70_Java_fragment()14301 public final void synpred70_Java_fragment() throws RecognitionException { 14302 // src/com/google/doclava/parser/Java.g:569:9: ( interfaceDeclaration ) 14303 dbg.enterAlt(1); 14304 14305 // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration 14306 { 14307 dbg.location(569,9); 14308 pushFollow(FOLLOW_interfaceDeclaration_in_synpred70_Java2192); 14309 interfaceDeclaration(); 14310 14311 state._fsp--; 14312 if (state.failed) return ; 14313 14314 } 14315 } 14316 // $ANTLR end synpred70_Java 14317 14318 // $ANTLR start synpred71_Java synpred71_Java_fragment()14319 public final void synpred71_Java_fragment() throws RecognitionException { 14320 // src/com/google/doclava/parser/Java.g:570:9: ( classDeclaration ) 14321 dbg.enterAlt(1); 14322 14323 // src/com/google/doclava/parser/Java.g:570:9: classDeclaration 14324 { 14325 dbg.location(570,9); 14326 pushFollow(FOLLOW_classDeclaration_in_synpred71_Java2202); 14327 classDeclaration(); 14328 14329 state._fsp--; 14330 if (state.failed) return ; 14331 14332 } 14333 } 14334 // $ANTLR end synpred71_Java 14335 14336 // $ANTLR start synpred96_Java synpred96_Java_fragment()14337 public final void synpred96_Java_fragment() throws RecognitionException { 14338 // src/com/google/doclava/parser/Java.g:665:9: ( ellipsisParameterDecl ) 14339 dbg.enterAlt(1); 14340 14341 // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl 14342 { 14343 dbg.location(665,9); 14344 pushFollow(FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953); 14345 ellipsisParameterDecl(); 14346 14347 state._fsp--; 14348 if (state.failed) return ; 14349 14350 } 14351 } 14352 // $ANTLR end synpred96_Java 14353 14354 // $ANTLR start synpred98_Java synpred98_Java_fragment()14355 public final void synpred98_Java_fragment() throws RecognitionException { 14356 // src/com/google/doclava/parser/Java.g:666:9: ( normalParameterDecl ( ',' normalParameterDecl )* ) 14357 dbg.enterAlt(1); 14358 14359 // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )* 14360 { 14361 dbg.location(666,9); 14362 pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2963); 14363 normalParameterDecl(); 14364 14365 state._fsp--; 14366 if (state.failed) return ; 14367 dbg.location(667,9); 14368 // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )* 14369 try { dbg.enterSubRule(175); 14370 14371 loop175: 14372 do { 14373 int alt175=2; 14374 try { dbg.enterDecision(175, decisionCanBacktrack[175]); 14375 14376 int LA175_0 = input.LA(1); 14377 14378 if ( (LA175_0==COMMA) ) { 14379 alt175=1; 14380 } 14381 14382 14383 } finally {dbg.exitDecision(175);} 14384 14385 switch (alt175) { 14386 case 1 : 14387 dbg.enterAlt(1); 14388 14389 // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl 14390 { 14391 dbg.location(667,10); 14392 match(input,COMMA,FOLLOW_COMMA_in_synpred98_Java2974); if (state.failed) return ; 14393 dbg.location(667,14); 14394 pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2976); 14395 normalParameterDecl(); 14396 14397 state._fsp--; 14398 if (state.failed) return ; 14399 14400 } 14401 break; 14402 14403 default : 14404 break loop175; 14405 } 14406 } while (true); 14407 } finally {dbg.exitSubRule(175);} 14408 14409 14410 } 14411 } 14412 // $ANTLR end synpred98_Java 14413 14414 // $ANTLR start synpred99_Java synpred99_Java_fragment()14415 public final void synpred99_Java_fragment() throws RecognitionException { 14416 // src/com/google/doclava/parser/Java.g:669:10: ( normalParameterDecl ',' ) 14417 dbg.enterAlt(1); 14418 14419 // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ',' 14420 { 14421 dbg.location(669,10); 14422 pushFollow(FOLLOW_normalParameterDecl_in_synpred99_Java2998); 14423 normalParameterDecl(); 14424 14425 state._fsp--; 14426 if (state.failed) return ; 14427 dbg.location(670,9); 14428 match(input,COMMA,FOLLOW_COMMA_in_synpred99_Java3008); if (state.failed) return ; 14429 14430 } 14431 } 14432 // $ANTLR end synpred99_Java 14433 14434 // $ANTLR start synpred103_Java synpred103_Java_fragment()14435 public final void synpred103_Java_fragment() throws RecognitionException { 14436 // src/com/google/doclava/parser/Java.g:689:9: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' ) 14437 dbg.enterAlt(1); 14438 14439 // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' 14440 { 14441 dbg.location(689,9); 14442 // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? 14443 int alt176=2; 14444 try { dbg.enterSubRule(176); 14445 try { dbg.enterDecision(176, decisionCanBacktrack[176]); 14446 14447 int LA176_0 = input.LA(1); 14448 14449 if ( (LA176_0==LT) ) { 14450 alt176=1; 14451 } 14452 } finally {dbg.exitDecision(176);} 14453 14454 switch (alt176) { 14455 case 1 : 14456 dbg.enterAlt(1); 14457 14458 // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments 14459 { 14460 dbg.location(689,10); 14461 pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139); 14462 nonWildcardTypeArguments(); 14463 14464 state._fsp--; 14465 if (state.failed) return ; 14466 14467 } 14468 break; 14469 14470 } 14471 } finally {dbg.exitSubRule(176);} 14472 14473 dbg.location(691,9); 14474 if ( input.LA(1)==SUPER||input.LA(1)==THIS ) { 14475 input.consume(); 14476 state.errorRecovery=false;state.failed=false; 14477 } 14478 else { 14479 if (state.backtracking>0) {state.failed=true; return ;} 14480 MismatchedSetException mse = new MismatchedSetException(null,input); 14481 dbg.recognitionException(mse); 14482 throw mse; 14483 } 14484 14485 dbg.location(694,9); 14486 pushFollow(FOLLOW_arguments_in_synpred103_Java3197); 14487 arguments(); 14488 14489 state._fsp--; 14490 if (state.failed) return ; 14491 dbg.location(694,19); 14492 match(input,SEMI,FOLLOW_SEMI_in_synpred103_Java3199); if (state.failed) return ; 14493 14494 } 14495 } 14496 // $ANTLR end synpred103_Java 14497 14498 // $ANTLR start synpred117_Java synpred117_Java_fragment()14499 public final void synpred117_Java_fragment() throws RecognitionException { 14500 // src/com/google/doclava/parser/Java.g:776:9: ( annotationMethodDeclaration ) 14501 dbg.enterAlt(1); 14502 14503 // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration 14504 { 14505 dbg.location(776,9); 14506 pushFollow(FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781); 14507 annotationMethodDeclaration(); 14508 14509 state._fsp--; 14510 if (state.failed) return ; 14511 14512 } 14513 } 14514 // $ANTLR end synpred117_Java 14515 14516 // $ANTLR start synpred118_Java synpred118_Java_fragment()14517 public final void synpred118_Java_fragment() throws RecognitionException { 14518 // src/com/google/doclava/parser/Java.g:777:9: ( interfaceFieldDeclaration ) 14519 dbg.enterAlt(1); 14520 14521 // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration 14522 { 14523 dbg.location(777,9); 14524 pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791); 14525 interfaceFieldDeclaration(); 14526 14527 state._fsp--; 14528 if (state.failed) return ; 14529 14530 } 14531 } 14532 // $ANTLR end synpred118_Java 14533 14534 // $ANTLR start synpred119_Java synpred119_Java_fragment()14535 public final void synpred119_Java_fragment() throws RecognitionException { 14536 // src/com/google/doclava/parser/Java.g:778:9: ( normalClassDeclaration ) 14537 dbg.enterAlt(1); 14538 14539 // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration 14540 { 14541 dbg.location(778,9); 14542 pushFollow(FOLLOW_normalClassDeclaration_in_synpred119_Java3801); 14543 normalClassDeclaration(); 14544 14545 state._fsp--; 14546 if (state.failed) return ; 14547 14548 } 14549 } 14550 // $ANTLR end synpred119_Java 14551 14552 // $ANTLR start synpred120_Java synpred120_Java_fragment()14553 public final void synpred120_Java_fragment() throws RecognitionException { 14554 // src/com/google/doclava/parser/Java.g:779:9: ( normalInterfaceDeclaration ) 14555 dbg.enterAlt(1); 14556 14557 // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration 14558 { 14559 dbg.location(779,9); 14560 pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811); 14561 normalInterfaceDeclaration(); 14562 14563 state._fsp--; 14564 if (state.failed) return ; 14565 14566 } 14567 } 14568 // $ANTLR end synpred120_Java 14569 14570 // $ANTLR start synpred121_Java synpred121_Java_fragment()14571 public final void synpred121_Java_fragment() throws RecognitionException { 14572 // src/com/google/doclava/parser/Java.g:780:9: ( enumDeclaration ) 14573 dbg.enterAlt(1); 14574 14575 // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration 14576 { 14577 dbg.location(780,9); 14578 pushFollow(FOLLOW_enumDeclaration_in_synpred121_Java3821); 14579 enumDeclaration(); 14580 14581 state._fsp--; 14582 if (state.failed) return ; 14583 14584 } 14585 } 14586 // $ANTLR end synpred121_Java 14587 14588 // $ANTLR start synpred122_Java synpred122_Java_fragment()14589 public final void synpred122_Java_fragment() throws RecognitionException { 14590 // src/com/google/doclava/parser/Java.g:781:9: ( annotationTypeDeclaration ) 14591 dbg.enterAlt(1); 14592 14593 // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration 14594 { 14595 dbg.location(781,9); 14596 pushFollow(FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831); 14597 annotationTypeDeclaration(); 14598 14599 state._fsp--; 14600 if (state.failed) return ; 14601 14602 } 14603 } 14604 // $ANTLR end synpred122_Java 14605 14606 // $ANTLR start synpred125_Java synpred125_Java_fragment()14607 public final void synpred125_Java_fragment() throws RecognitionException { 14608 // src/com/google/doclava/parser/Java.g:824:9: ( localVariableDeclarationStatement ) 14609 dbg.enterAlt(1); 14610 14611 // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement 14612 { 14613 dbg.location(824,9); 14614 pushFollow(FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986); 14615 localVariableDeclarationStatement(); 14616 14617 state._fsp--; 14618 if (state.failed) return ; 14619 14620 } 14621 } 14622 // $ANTLR end synpred125_Java 14623 14624 // $ANTLR start synpred126_Java synpred126_Java_fragment()14625 public final void synpred126_Java_fragment() throws RecognitionException { 14626 // src/com/google/doclava/parser/Java.g:825:9: ( classOrInterfaceDeclaration ) 14627 dbg.enterAlt(1); 14628 14629 // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration 14630 { 14631 dbg.location(825,9); 14632 pushFollow(FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996); 14633 classOrInterfaceDeclaration(); 14634 14635 state._fsp--; 14636 if (state.failed) return ; 14637 14638 } 14639 } 14640 // $ANTLR end synpred126_Java 14641 14642 // $ANTLR start synpred130_Java synpred130_Java_fragment()14643 public final void synpred130_Java_fragment() throws RecognitionException { 14644 // src/com/google/doclava/parser/Java.g:845:9: ( ( 'assert' ) expression ( ':' expression )? ';' ) 14645 dbg.enterAlt(1); 14646 14647 // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';' 14648 { 14649 dbg.location(845,9); 14650 // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) 14651 dbg.enterAlt(1); 14652 14653 // src/com/google/doclava/parser/Java.g:845:10: 'assert' 14654 { 14655 dbg.location(845,10); 14656 match(input,ASSERT,FOLLOW_ASSERT_in_synpred130_Java4122); if (state.failed) return ; 14657 14658 } 14659 14660 dbg.location(847,9); 14661 pushFollow(FOLLOW_expression_in_synpred130_Java4142); 14662 expression(); 14663 14664 state._fsp--; 14665 if (state.failed) return ; 14666 dbg.location(847,20); 14667 // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )? 14668 int alt179=2; 14669 try { dbg.enterSubRule(179); 14670 try { dbg.enterDecision(179, decisionCanBacktrack[179]); 14671 14672 int LA179_0 = input.LA(1); 14673 14674 if ( (LA179_0==COLON) ) { 14675 alt179=1; 14676 } 14677 } finally {dbg.exitDecision(179);} 14678 14679 switch (alt179) { 14680 case 1 : 14681 dbg.enterAlt(1); 14682 14683 // src/com/google/doclava/parser/Java.g:847:21: ':' expression 14684 { 14685 dbg.location(847,21); 14686 match(input,COLON,FOLLOW_COLON_in_synpred130_Java4145); if (state.failed) return ; 14687 dbg.location(847,25); 14688 pushFollow(FOLLOW_expression_in_synpred130_Java4147); 14689 expression(); 14690 14691 state._fsp--; 14692 if (state.failed) return ; 14693 14694 } 14695 break; 14696 14697 } 14698 } finally {dbg.exitSubRule(179);} 14699 14700 dbg.location(847,38); 14701 match(input,SEMI,FOLLOW_SEMI_in_synpred130_Java4151); if (state.failed) return ; 14702 14703 } 14704 } 14705 // $ANTLR end synpred130_Java 14706 14707 // $ANTLR start synpred132_Java synpred132_Java_fragment()14708 public final void synpred132_Java_fragment() throws RecognitionException { 14709 // src/com/google/doclava/parser/Java.g:848:9: ( 'assert' expression ( ':' expression )? ';' ) 14710 dbg.enterAlt(1); 14711 14712 // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';' 14713 { 14714 dbg.location(848,9); 14715 match(input,ASSERT,FOLLOW_ASSERT_in_synpred132_Java4161); if (state.failed) return ; 14716 dbg.location(848,19); 14717 pushFollow(FOLLOW_expression_in_synpred132_Java4164); 14718 expression(); 14719 14720 state._fsp--; 14721 if (state.failed) return ; 14722 dbg.location(848,30); 14723 // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )? 14724 int alt180=2; 14725 try { dbg.enterSubRule(180); 14726 try { dbg.enterDecision(180, decisionCanBacktrack[180]); 14727 14728 int LA180_0 = input.LA(1); 14729 14730 if ( (LA180_0==COLON) ) { 14731 alt180=1; 14732 } 14733 } finally {dbg.exitDecision(180);} 14734 14735 switch (alt180) { 14736 case 1 : 14737 dbg.enterAlt(1); 14738 14739 // src/com/google/doclava/parser/Java.g:848:31: ':' expression 14740 { 14741 dbg.location(848,31); 14742 match(input,COLON,FOLLOW_COLON_in_synpred132_Java4167); if (state.failed) return ; 14743 dbg.location(848,35); 14744 pushFollow(FOLLOW_expression_in_synpred132_Java4169); 14745 expression(); 14746 14747 state._fsp--; 14748 if (state.failed) return ; 14749 14750 } 14751 break; 14752 14753 } 14754 } finally {dbg.exitSubRule(180);} 14755 14756 dbg.location(848,48); 14757 match(input,SEMI,FOLLOW_SEMI_in_synpred132_Java4173); if (state.failed) return ; 14758 14759 } 14760 } 14761 // $ANTLR end synpred132_Java 14762 14763 // $ANTLR start synpred133_Java synpred133_Java_fragment()14764 public final void synpred133_Java_fragment() throws RecognitionException { 14765 // src/com/google/doclava/parser/Java.g:849:39: ( 'else' statement ) 14766 dbg.enterAlt(1); 14767 14768 // src/com/google/doclava/parser/Java.g:849:39: 'else' statement 14769 { 14770 dbg.location(849,39); 14771 match(input,ELSE,FOLLOW_ELSE_in_synpred133_Java4190); if (state.failed) return ; 14772 dbg.location(849,46); 14773 pushFollow(FOLLOW_statement_in_synpred133_Java4192); 14774 statement(); 14775 14776 state._fsp--; 14777 if (state.failed) return ; 14778 14779 } 14780 } 14781 // $ANTLR end synpred133_Java 14782 14783 // $ANTLR start synpred148_Java synpred148_Java_fragment()14784 public final void synpred148_Java_fragment() throws RecognitionException { 14785 // src/com/google/doclava/parser/Java.g:864:9: ( expression ';' ) 14786 dbg.enterAlt(1); 14787 14788 // src/com/google/doclava/parser/Java.g:864:9: expression ';' 14789 { 14790 dbg.location(864,9); 14791 pushFollow(FOLLOW_expression_in_synpred148_Java4404); 14792 expression(); 14793 14794 state._fsp--; 14795 if (state.failed) return ; 14796 dbg.location(864,21); 14797 match(input,SEMI,FOLLOW_SEMI_in_synpred148_Java4407); if (state.failed) return ; 14798 14799 } 14800 } 14801 // $ANTLR end synpred148_Java 14802 14803 // $ANTLR start synpred149_Java synpred149_Java_fragment()14804 public final void synpred149_Java_fragment() throws RecognitionException { 14805 // src/com/google/doclava/parser/Java.g:865:9: ( IDENTIFIER ':' statement ) 14806 dbg.enterAlt(1); 14807 14808 // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement 14809 { 14810 dbg.location(865,9); 14811 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred149_Java4417); if (state.failed) return ; 14812 dbg.location(865,20); 14813 match(input,COLON,FOLLOW_COLON_in_synpred149_Java4419); if (state.failed) return ; 14814 dbg.location(865,24); 14815 pushFollow(FOLLOW_statement_in_synpred149_Java4421); 14816 statement(); 14817 14818 state._fsp--; 14819 if (state.failed) return ; 14820 14821 } 14822 } 14823 // $ANTLR end synpred149_Java 14824 14825 // $ANTLR start synpred153_Java synpred153_Java_fragment()14826 public final void synpred153_Java_fragment() throws RecognitionException { 14827 // src/com/google/doclava/parser/Java.g:889:13: ( catches 'finally' block ) 14828 dbg.enterAlt(1); 14829 14830 // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block 14831 { 14832 dbg.location(889,13); 14833 pushFollow(FOLLOW_catches_in_synpred153_Java4573); 14834 catches(); 14835 14836 state._fsp--; 14837 if (state.failed) return ; 14838 dbg.location(889,21); 14839 match(input,FINALLY,FOLLOW_FINALLY_in_synpred153_Java4575); if (state.failed) return ; 14840 dbg.location(889,31); 14841 pushFollow(FOLLOW_block_in_synpred153_Java4577); 14842 block(); 14843 14844 state._fsp--; 14845 if (state.failed) return ; 14846 14847 } 14848 } 14849 // $ANTLR end synpred153_Java 14850 14851 // $ANTLR start synpred154_Java synpred154_Java_fragment()14852 public final void synpred154_Java_fragment() throws RecognitionException { 14853 // src/com/google/doclava/parser/Java.g:890:13: ( catches ) 14854 dbg.enterAlt(1); 14855 14856 // src/com/google/doclava/parser/Java.g:890:13: catches 14857 { 14858 dbg.location(890,13); 14859 pushFollow(FOLLOW_catches_in_synpred154_Java4591); 14860 catches(); 14861 14862 state._fsp--; 14863 if (state.failed) return ; 14864 14865 } 14866 } 14867 // $ANTLR end synpred154_Java 14868 14869 // $ANTLR start synpred157_Java synpred157_Java_fragment()14870 public final void synpred157_Java_fragment() throws RecognitionException { 14871 // src/com/google/doclava/parser/Java.g:915:9: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement ) 14872 dbg.enterAlt(1); 14873 14874 // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement 14875 { 14876 dbg.location(915,9); 14877 match(input,FOR,FOLLOW_FOR_in_synpred157_Java4775); if (state.failed) return ; 14878 dbg.location(915,15); 14879 match(input,LPAREN,FOLLOW_LPAREN_in_synpred157_Java4777); if (state.failed) return ; 14880 dbg.location(915,19); 14881 pushFollow(FOLLOW_variableModifiers_in_synpred157_Java4779); 14882 variableModifiers(); 14883 14884 state._fsp--; 14885 if (state.failed) return ; 14886 dbg.location(915,37); 14887 pushFollow(FOLLOW_type_in_synpred157_Java4781); 14888 type(); 14889 14890 state._fsp--; 14891 if (state.failed) return ; 14892 dbg.location(915,42); 14893 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred157_Java4783); if (state.failed) return ; 14894 dbg.location(915,53); 14895 match(input,COLON,FOLLOW_COLON_in_synpred157_Java4785); if (state.failed) return ; 14896 dbg.location(916,9); 14897 pushFollow(FOLLOW_expression_in_synpred157_Java4795); 14898 expression(); 14899 14900 state._fsp--; 14901 if (state.failed) return ; 14902 dbg.location(916,20); 14903 match(input,RPAREN,FOLLOW_RPAREN_in_synpred157_Java4797); if (state.failed) return ; 14904 dbg.location(916,24); 14905 pushFollow(FOLLOW_statement_in_synpred157_Java4799); 14906 statement(); 14907 14908 state._fsp--; 14909 if (state.failed) return ; 14910 14911 } 14912 } 14913 // $ANTLR end synpred157_Java 14914 14915 // $ANTLR start synpred161_Java synpred161_Java_fragment()14916 public final void synpred161_Java_fragment() throws RecognitionException { 14917 // src/com/google/doclava/parser/Java.g:929:9: ( localVariableDeclaration ) 14918 dbg.enterAlt(1); 14919 14920 // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration 14921 { 14922 dbg.location(929,9); 14923 pushFollow(FOLLOW_localVariableDeclaration_in_synpred161_Java4962); 14924 localVariableDeclaration(); 14925 14926 state._fsp--; 14927 if (state.failed) return ; 14928 14929 } 14930 } 14931 // $ANTLR end synpred161_Java 14932 14933 // $ANTLR start synpred202_Java synpred202_Java_fragment()14934 public final void synpred202_Java_fragment() throws RecognitionException { 14935 // src/com/google/doclava/parser/Java.g:1083:9: ( castExpression ) 14936 dbg.enterAlt(1); 14937 14938 // src/com/google/doclava/parser/Java.g:1083:9: castExpression 14939 { 14940 dbg.location(1083,9); 14941 pushFollow(FOLLOW_castExpression_in_synpred202_Java6178); 14942 castExpression(); 14943 14944 state._fsp--; 14945 if (state.failed) return ; 14946 14947 } 14948 } 14949 // $ANTLR end synpred202_Java 14950 14951 // $ANTLR start synpred206_Java synpred206_Java_fragment()14952 public final void synpred206_Java_fragment() throws RecognitionException { 14953 // src/com/google/doclava/parser/Java.g:1093:9: ( '(' primitiveType ')' unaryExpression ) 14954 dbg.enterAlt(1); 14955 14956 // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression 14957 { 14958 dbg.location(1093,9); 14959 match(input,LPAREN,FOLLOW_LPAREN_in_synpred206_Java6268); if (state.failed) return ; 14960 dbg.location(1093,13); 14961 pushFollow(FOLLOW_primitiveType_in_synpred206_Java6270); 14962 primitiveType(); 14963 14964 state._fsp--; 14965 if (state.failed) return ; 14966 dbg.location(1093,27); 14967 match(input,RPAREN,FOLLOW_RPAREN_in_synpred206_Java6272); if (state.failed) return ; 14968 dbg.location(1093,31); 14969 pushFollow(FOLLOW_unaryExpression_in_synpred206_Java6274); 14970 unaryExpression(); 14971 14972 state._fsp--; 14973 if (state.failed) return ; 14974 14975 } 14976 } 14977 // $ANTLR end synpred206_Java 14978 14979 // $ANTLR start synpred208_Java synpred208_Java_fragment()14980 public final void synpred208_Java_fragment() throws RecognitionException { 14981 // src/com/google/doclava/parser/Java.g:1103:10: ( '.' IDENTIFIER ) 14982 dbg.enterAlt(1); 14983 14984 // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER 14985 { 14986 dbg.location(1103,10); 14987 match(input,DOT,FOLLOW_DOT_in_synpred208_Java6332); if (state.failed) return ; 14988 dbg.location(1103,14); 14989 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred208_Java6334); if (state.failed) return ; 14990 14991 } 14992 } 14993 // $ANTLR end synpred208_Java 14994 14995 // $ANTLR start synpred209_Java synpred209_Java_fragment()14996 public final void synpred209_Java_fragment() throws RecognitionException { 14997 // src/com/google/doclava/parser/Java.g:1105:10: ( identifierSuffix ) 14998 dbg.enterAlt(1); 14999 15000 // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix 15001 { 15002 dbg.location(1105,10); 15003 pushFollow(FOLLOW_identifierSuffix_in_synpred209_Java6356); 15004 identifierSuffix(); 15005 15006 state._fsp--; 15007 if (state.failed) return ; 15008 15009 } 15010 } 15011 // $ANTLR end synpred209_Java 15012 15013 // $ANTLR start synpred211_Java synpred211_Java_fragment()15014 public final void synpred211_Java_fragment() throws RecognitionException { 15015 // src/com/google/doclava/parser/Java.g:1108:10: ( '.' IDENTIFIER ) 15016 dbg.enterAlt(1); 15017 15018 // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER 15019 { 15020 dbg.location(1108,10); 15021 match(input,DOT,FOLLOW_DOT_in_synpred211_Java6388); if (state.failed) return ; 15022 dbg.location(1108,14); 15023 match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred211_Java6390); if (state.failed) return ; 15024 15025 } 15026 } 15027 // $ANTLR end synpred211_Java 15028 15029 // $ANTLR start synpred212_Java synpred212_Java_fragment()15030 public final void synpred212_Java_fragment() throws RecognitionException { 15031 // src/com/google/doclava/parser/Java.g:1110:10: ( identifierSuffix ) 15032 dbg.enterAlt(1); 15033 15034 // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix 15035 { 15036 dbg.location(1110,10); 15037 pushFollow(FOLLOW_identifierSuffix_in_synpred212_Java6412); 15038 identifierSuffix(); 15039 15040 state._fsp--; 15041 if (state.failed) return ; 15042 15043 } 15044 } 15045 // $ANTLR end synpred212_Java 15046 15047 // $ANTLR start synpred224_Java synpred224_Java_fragment()15048 public final void synpred224_Java_fragment() throws RecognitionException { 15049 // src/com/google/doclava/parser/Java.g:1138:10: ( '[' expression ']' ) 15050 dbg.enterAlt(1); 15051 15052 // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']' 15053 { 15054 dbg.location(1138,10); 15055 match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred224_Java6656); if (state.failed) return ; 15056 dbg.location(1138,14); 15057 pushFollow(FOLLOW_expression_in_synpred224_Java6658); 15058 expression(); 15059 15060 state._fsp--; 15061 if (state.failed) return ; 15062 dbg.location(1138,25); 15063 match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred224_Java6660); if (state.failed) return ; 15064 15065 } 15066 } 15067 // $ANTLR end synpred224_Java 15068 15069 // $ANTLR start synpred236_Java synpred236_Java_fragment()15070 public final void synpred236_Java_fragment() throws RecognitionException { 15071 // src/com/google/doclava/parser/Java.g:1161:9: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest ) 15072 dbg.enterAlt(1); 15073 15074 // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest 15075 { 15076 dbg.location(1161,9); 15077 match(input,NEW,FOLLOW_NEW_in_synpred236_Java6866); if (state.failed) return ; 15078 dbg.location(1161,15); 15079 pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868); 15080 nonWildcardTypeArguments(); 15081 15082 state._fsp--; 15083 if (state.failed) return ; 15084 dbg.location(1161,40); 15085 pushFollow(FOLLOW_classOrInterfaceType_in_synpred236_Java6870); 15086 classOrInterfaceType(); 15087 15088 state._fsp--; 15089 if (state.failed) return ; 15090 dbg.location(1161,61); 15091 pushFollow(FOLLOW_classCreatorRest_in_synpred236_Java6872); 15092 classCreatorRest(); 15093 15094 state._fsp--; 15095 if (state.failed) return ; 15096 15097 } 15098 } 15099 // $ANTLR end synpred236_Java 15100 15101 // $ANTLR start synpred237_Java synpred237_Java_fragment()15102 public final void synpred237_Java_fragment() throws RecognitionException { 15103 // src/com/google/doclava/parser/Java.g:1162:9: ( 'new' classOrInterfaceType classCreatorRest ) 15104 dbg.enterAlt(1); 15105 15106 // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest 15107 { 15108 dbg.location(1162,9); 15109 match(input,NEW,FOLLOW_NEW_in_synpred237_Java6882); if (state.failed) return ; 15110 dbg.location(1162,15); 15111 pushFollow(FOLLOW_classOrInterfaceType_in_synpred237_Java6884); 15112 classOrInterfaceType(); 15113 15114 state._fsp--; 15115 if (state.failed) return ; 15116 dbg.location(1162,36); 15117 pushFollow(FOLLOW_classCreatorRest_in_synpred237_Java6886); 15118 classCreatorRest(); 15119 15120 state._fsp--; 15121 if (state.failed) return ; 15122 15123 } 15124 } 15125 // $ANTLR end synpred237_Java 15126 15127 // $ANTLR start synpred239_Java synpred239_Java_fragment()15128 public final void synpred239_Java_fragment() throws RecognitionException { 15129 // src/com/google/doclava/parser/Java.g:1167:9: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer ) 15130 dbg.enterAlt(1); 15131 15132 // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer 15133 { 15134 dbg.location(1167,9); 15135 match(input,NEW,FOLLOW_NEW_in_synpred239_Java6915); if (state.failed) return ; 15136 dbg.location(1167,15); 15137 pushFollow(FOLLOW_createdName_in_synpred239_Java6917); 15138 createdName(); 15139 15140 state._fsp--; 15141 if (state.failed) return ; 15142 dbg.location(1168,9); 15143 match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6927); if (state.failed) return ; 15144 dbg.location(1168,13); 15145 match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6929); if (state.failed) return ; 15146 dbg.location(1169,9); 15147 // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )* 15148 try { dbg.enterSubRule(193); 15149 15150 loop193: 15151 do { 15152 int alt193=2; 15153 try { dbg.enterDecision(193, decisionCanBacktrack[193]); 15154 15155 int LA193_0 = input.LA(1); 15156 15157 if ( (LA193_0==LBRACKET) ) { 15158 alt193=1; 15159 } 15160 15161 15162 } finally {dbg.exitDecision(193);} 15163 15164 switch (alt193) { 15165 case 1 : 15166 dbg.enterAlt(1); 15167 15168 // src/com/google/doclava/parser/Java.g:1169:10: '[' ']' 15169 { 15170 dbg.location(1169,10); 15171 match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6940); if (state.failed) return ; 15172 dbg.location(1169,14); 15173 match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6942); if (state.failed) return ; 15174 15175 } 15176 break; 15177 15178 default : 15179 break loop193; 15180 } 15181 } while (true); 15182 } finally {dbg.exitSubRule(193);} 15183 15184 dbg.location(1171,9); 15185 pushFollow(FOLLOW_arrayInitializer_in_synpred239_Java6963); 15186 arrayInitializer(); 15187 15188 state._fsp--; 15189 if (state.failed) return ; 15190 15191 } 15192 } 15193 // $ANTLR end synpred239_Java 15194 15195 // $ANTLR start synpred240_Java synpred240_Java_fragment()15196 public final void synpred240_Java_fragment() throws RecognitionException { 15197 // src/com/google/doclava/parser/Java.g:1176:13: ( '[' expression ']' ) 15198 dbg.enterAlt(1); 15199 15200 // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']' 15201 { 15202 dbg.location(1176,13); 15203 match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred240_Java7012); if (state.failed) return ; 15204 dbg.location(1176,17); 15205 pushFollow(FOLLOW_expression_in_synpred240_Java7014); 15206 expression(); 15207 15208 state._fsp--; 15209 if (state.failed) return ; 15210 dbg.location(1177,13); 15211 match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred240_Java7028); if (state.failed) return ; 15212 15213 } 15214 } 15215 // $ANTLR end synpred240_Java 15216 15217 // Delegated rules 15218 synpred43_Java()15219 public final boolean synpred43_Java() { 15220 state.backtracking++; 15221 dbg.beginBacktrack(state.backtracking); 15222 int start = input.mark(); 15223 try { 15224 synpred43_Java_fragment(); // can never throw exception 15225 } catch (RecognitionException re) { 15226 System.err.println("impossible: "+re); 15227 } 15228 boolean success = !state.failed; 15229 input.rewind(start); 15230 dbg.endBacktrack(state.backtracking, success); 15231 state.backtracking--; 15232 state.failed=false; 15233 return success; 15234 } synpred98_Java()15235 public final boolean synpred98_Java() { 15236 state.backtracking++; 15237 dbg.beginBacktrack(state.backtracking); 15238 int start = input.mark(); 15239 try { 15240 synpred98_Java_fragment(); // can never throw exception 15241 } catch (RecognitionException re) { 15242 System.err.println("impossible: "+re); 15243 } 15244 boolean success = !state.failed; 15245 input.rewind(start); 15246 dbg.endBacktrack(state.backtracking, success); 15247 state.backtracking--; 15248 state.failed=false; 15249 return success; 15250 } synpred157_Java()15251 public final boolean synpred157_Java() { 15252 state.backtracking++; 15253 dbg.beginBacktrack(state.backtracking); 15254 int start = input.mark(); 15255 try { 15256 synpred157_Java_fragment(); // can never throw exception 15257 } catch (RecognitionException re) { 15258 System.err.println("impossible: "+re); 15259 } 15260 boolean success = !state.failed; 15261 input.rewind(start); 15262 dbg.endBacktrack(state.backtracking, success); 15263 state.backtracking--; 15264 state.failed=false; 15265 return success; 15266 } synpred224_Java()15267 public final boolean synpred224_Java() { 15268 state.backtracking++; 15269 dbg.beginBacktrack(state.backtracking); 15270 int start = input.mark(); 15271 try { 15272 synpred224_Java_fragment(); // can never throw exception 15273 } catch (RecognitionException re) { 15274 System.err.println("impossible: "+re); 15275 } 15276 boolean success = !state.failed; 15277 input.rewind(start); 15278 dbg.endBacktrack(state.backtracking, success); 15279 state.backtracking--; 15280 state.failed=false; 15281 return success; 15282 } synpred211_Java()15283 public final boolean synpred211_Java() { 15284 state.backtracking++; 15285 dbg.beginBacktrack(state.backtracking); 15286 int start = input.mark(); 15287 try { 15288 synpred211_Java_fragment(); // can never throw exception 15289 } catch (RecognitionException re) { 15290 System.err.println("impossible: "+re); 15291 } 15292 boolean success = !state.failed; 15293 input.rewind(start); 15294 dbg.endBacktrack(state.backtracking, success); 15295 state.backtracking--; 15296 state.failed=false; 15297 return success; 15298 } synpred121_Java()15299 public final boolean synpred121_Java() { 15300 state.backtracking++; 15301 dbg.beginBacktrack(state.backtracking); 15302 int start = input.mark(); 15303 try { 15304 synpred121_Java_fragment(); // can never throw exception 15305 } catch (RecognitionException re) { 15306 System.err.println("impossible: "+re); 15307 } 15308 boolean success = !state.failed; 15309 input.rewind(start); 15310 dbg.endBacktrack(state.backtracking, success); 15311 state.backtracking--; 15312 state.failed=false; 15313 return success; 15314 } synpred239_Java()15315 public final boolean synpred239_Java() { 15316 state.backtracking++; 15317 dbg.beginBacktrack(state.backtracking); 15318 int start = input.mark(); 15319 try { 15320 synpred239_Java_fragment(); // can never throw exception 15321 } catch (RecognitionException re) { 15322 System.err.println("impossible: "+re); 15323 } 15324 boolean success = !state.failed; 15325 input.rewind(start); 15326 dbg.endBacktrack(state.backtracking, success); 15327 state.backtracking--; 15328 state.failed=false; 15329 return success; 15330 } synpred69_Java()15331 public final boolean synpred69_Java() { 15332 state.backtracking++; 15333 dbg.beginBacktrack(state.backtracking); 15334 int start = input.mark(); 15335 try { 15336 synpred69_Java_fragment(); // can never throw exception 15337 } catch (RecognitionException re) { 15338 System.err.println("impossible: "+re); 15339 } 15340 boolean success = !state.failed; 15341 input.rewind(start); 15342 dbg.endBacktrack(state.backtracking, success); 15343 state.backtracking--; 15344 state.failed=false; 15345 return success; 15346 } synpred202_Java()15347 public final boolean synpred202_Java() { 15348 state.backtracking++; 15349 dbg.beginBacktrack(state.backtracking); 15350 int start = input.mark(); 15351 try { 15352 synpred202_Java_fragment(); // can never throw exception 15353 } catch (RecognitionException re) { 15354 System.err.println("impossible: "+re); 15355 } 15356 boolean success = !state.failed; 15357 input.rewind(start); 15358 dbg.endBacktrack(state.backtracking, success); 15359 state.backtracking--; 15360 state.failed=false; 15361 return success; 15362 } synpred154_Java()15363 public final boolean synpred154_Java() { 15364 state.backtracking++; 15365 dbg.beginBacktrack(state.backtracking); 15366 int start = input.mark(); 15367 try { 15368 synpred154_Java_fragment(); // can never throw exception 15369 } catch (RecognitionException re) { 15370 System.err.println("impossible: "+re); 15371 } 15372 boolean success = !state.failed; 15373 input.rewind(start); 15374 dbg.endBacktrack(state.backtracking, success); 15375 state.backtracking--; 15376 state.failed=false; 15377 return success; 15378 } synpred71_Java()15379 public final boolean synpred71_Java() { 15380 state.backtracking++; 15381 dbg.beginBacktrack(state.backtracking); 15382 int start = input.mark(); 15383 try { 15384 synpred71_Java_fragment(); // can never throw exception 15385 } catch (RecognitionException re) { 15386 System.err.println("impossible: "+re); 15387 } 15388 boolean success = !state.failed; 15389 input.rewind(start); 15390 dbg.endBacktrack(state.backtracking, success); 15391 state.backtracking--; 15392 state.failed=false; 15393 return success; 15394 } synpred133_Java()15395 public final boolean synpred133_Java() { 15396 state.backtracking++; 15397 dbg.beginBacktrack(state.backtracking); 15398 int start = input.mark(); 15399 try { 15400 synpred133_Java_fragment(); // can never throw exception 15401 } catch (RecognitionException re) { 15402 System.err.println("impossible: "+re); 15403 } 15404 boolean success = !state.failed; 15405 input.rewind(start); 15406 dbg.endBacktrack(state.backtracking, success); 15407 state.backtracking--; 15408 state.failed=false; 15409 return success; 15410 } synpred125_Java()15411 public final boolean synpred125_Java() { 15412 state.backtracking++; 15413 dbg.beginBacktrack(state.backtracking); 15414 int start = input.mark(); 15415 try { 15416 synpred125_Java_fragment(); // can never throw exception 15417 } catch (RecognitionException re) { 15418 System.err.println("impossible: "+re); 15419 } 15420 boolean success = !state.failed; 15421 input.rewind(start); 15422 dbg.endBacktrack(state.backtracking, success); 15423 state.backtracking--; 15424 state.failed=false; 15425 return success; 15426 } synpred132_Java()15427 public final boolean synpred132_Java() { 15428 state.backtracking++; 15429 dbg.beginBacktrack(state.backtracking); 15430 int start = input.mark(); 15431 try { 15432 synpred132_Java_fragment(); // can never throw exception 15433 } catch (RecognitionException re) { 15434 System.err.println("impossible: "+re); 15435 } 15436 boolean success = !state.failed; 15437 input.rewind(start); 15438 dbg.endBacktrack(state.backtracking, success); 15439 state.backtracking--; 15440 state.failed=false; 15441 return success; 15442 } synpred119_Java()15443 public final boolean synpred119_Java() { 15444 state.backtracking++; 15445 dbg.beginBacktrack(state.backtracking); 15446 int start = input.mark(); 15447 try { 15448 synpred119_Java_fragment(); // can never throw exception 15449 } catch (RecognitionException re) { 15450 System.err.println("impossible: "+re); 15451 } 15452 boolean success = !state.failed; 15453 input.rewind(start); 15454 dbg.endBacktrack(state.backtracking, success); 15455 state.backtracking--; 15456 state.failed=false; 15457 return success; 15458 } synpred54_Java()15459 public final boolean synpred54_Java() { 15460 state.backtracking++; 15461 dbg.beginBacktrack(state.backtracking); 15462 int start = input.mark(); 15463 try { 15464 synpred54_Java_fragment(); // can never throw exception 15465 } catch (RecognitionException re) { 15466 System.err.println("impossible: "+re); 15467 } 15468 boolean success = !state.failed; 15469 input.rewind(start); 15470 dbg.endBacktrack(state.backtracking, success); 15471 state.backtracking--; 15472 state.failed=false; 15473 return success; 15474 } synpred148_Java()15475 public final boolean synpred148_Java() { 15476 state.backtracking++; 15477 dbg.beginBacktrack(state.backtracking); 15478 int start = input.mark(); 15479 try { 15480 synpred148_Java_fragment(); // can never throw exception 15481 } catch (RecognitionException re) { 15482 System.err.println("impossible: "+re); 15483 } 15484 boolean success = !state.failed; 15485 input.rewind(start); 15486 dbg.endBacktrack(state.backtracking, success); 15487 state.backtracking--; 15488 state.failed=false; 15489 return success; 15490 } synpred117_Java()15491 public final boolean synpred117_Java() { 15492 state.backtracking++; 15493 dbg.beginBacktrack(state.backtracking); 15494 int start = input.mark(); 15495 try { 15496 synpred117_Java_fragment(); // can never throw exception 15497 } catch (RecognitionException re) { 15498 System.err.println("impossible: "+re); 15499 } 15500 boolean success = !state.failed; 15501 input.rewind(start); 15502 dbg.endBacktrack(state.backtracking, success); 15503 state.backtracking--; 15504 state.failed=false; 15505 return success; 15506 } synpred2_Java()15507 public final boolean synpred2_Java() { 15508 state.backtracking++; 15509 dbg.beginBacktrack(state.backtracking); 15510 int start = input.mark(); 15511 try { 15512 synpred2_Java_fragment(); // can never throw exception 15513 } catch (RecognitionException re) { 15514 System.err.println("impossible: "+re); 15515 } 15516 boolean success = !state.failed; 15517 input.rewind(start); 15518 dbg.endBacktrack(state.backtracking, success); 15519 state.backtracking--; 15520 state.failed=false; 15521 return success; 15522 } synpred130_Java()15523 public final boolean synpred130_Java() { 15524 state.backtracking++; 15525 dbg.beginBacktrack(state.backtracking); 15526 int start = input.mark(); 15527 try { 15528 synpred130_Java_fragment(); // can never throw exception 15529 } catch (RecognitionException re) { 15530 System.err.println("impossible: "+re); 15531 } 15532 boolean success = !state.failed; 15533 input.rewind(start); 15534 dbg.endBacktrack(state.backtracking, success); 15535 state.backtracking--; 15536 state.failed=false; 15537 return success; 15538 } synpred126_Java()15539 public final boolean synpred126_Java() { 15540 state.backtracking++; 15541 dbg.beginBacktrack(state.backtracking); 15542 int start = input.mark(); 15543 try { 15544 synpred126_Java_fragment(); // can never throw exception 15545 } catch (RecognitionException re) { 15546 System.err.println("impossible: "+re); 15547 } 15548 boolean success = !state.failed; 15549 input.rewind(start); 15550 dbg.endBacktrack(state.backtracking, success); 15551 state.backtracking--; 15552 state.failed=false; 15553 return success; 15554 } synpred59_Java()15555 public final boolean synpred59_Java() { 15556 state.backtracking++; 15557 dbg.beginBacktrack(state.backtracking); 15558 int start = input.mark(); 15559 try { 15560 synpred59_Java_fragment(); // can never throw exception 15561 } catch (RecognitionException re) { 15562 System.err.println("impossible: "+re); 15563 } 15564 boolean success = !state.failed; 15565 input.rewind(start); 15566 dbg.endBacktrack(state.backtracking, success); 15567 state.backtracking--; 15568 state.failed=false; 15569 return success; 15570 } synpred212_Java()15571 public final boolean synpred212_Java() { 15572 state.backtracking++; 15573 dbg.beginBacktrack(state.backtracking); 15574 int start = input.mark(); 15575 try { 15576 synpred212_Java_fragment(); // can never throw exception 15577 } catch (RecognitionException re) { 15578 System.err.println("impossible: "+re); 15579 } 15580 boolean success = !state.failed; 15581 input.rewind(start); 15582 dbg.endBacktrack(state.backtracking, success); 15583 state.backtracking--; 15584 state.failed=false; 15585 return success; 15586 } synpred161_Java()15587 public final boolean synpred161_Java() { 15588 state.backtracking++; 15589 dbg.beginBacktrack(state.backtracking); 15590 int start = input.mark(); 15591 try { 15592 synpred161_Java_fragment(); // can never throw exception 15593 } catch (RecognitionException re) { 15594 System.err.println("impossible: "+re); 15595 } 15596 boolean success = !state.failed; 15597 input.rewind(start); 15598 dbg.endBacktrack(state.backtracking, success); 15599 state.backtracking--; 15600 state.failed=false; 15601 return success; 15602 } synpred57_Java()15603 public final boolean synpred57_Java() { 15604 state.backtracking++; 15605 dbg.beginBacktrack(state.backtracking); 15606 int start = input.mark(); 15607 try { 15608 synpred57_Java_fragment(); // can never throw exception 15609 } catch (RecognitionException re) { 15610 System.err.println("impossible: "+re); 15611 } 15612 boolean success = !state.failed; 15613 input.rewind(start); 15614 dbg.endBacktrack(state.backtracking, success); 15615 state.backtracking--; 15616 state.failed=false; 15617 return success; 15618 } synpred209_Java()15619 public final boolean synpred209_Java() { 15620 state.backtracking++; 15621 dbg.beginBacktrack(state.backtracking); 15622 int start = input.mark(); 15623 try { 15624 synpred209_Java_fragment(); // can never throw exception 15625 } catch (RecognitionException re) { 15626 System.err.println("impossible: "+re); 15627 } 15628 boolean success = !state.failed; 15629 input.rewind(start); 15630 dbg.endBacktrack(state.backtracking, success); 15631 state.backtracking--; 15632 state.failed=false; 15633 return success; 15634 } synpred68_Java()15635 public final boolean synpred68_Java() { 15636 state.backtracking++; 15637 dbg.beginBacktrack(state.backtracking); 15638 int start = input.mark(); 15639 try { 15640 synpred68_Java_fragment(); // can never throw exception 15641 } catch (RecognitionException re) { 15642 System.err.println("impossible: "+re); 15643 } 15644 boolean success = !state.failed; 15645 input.rewind(start); 15646 dbg.endBacktrack(state.backtracking, success); 15647 state.backtracking--; 15648 state.failed=false; 15649 return success; 15650 } synpred53_Java()15651 public final boolean synpred53_Java() { 15652 state.backtracking++; 15653 dbg.beginBacktrack(state.backtracking); 15654 int start = input.mark(); 15655 try { 15656 synpred53_Java_fragment(); // can never throw exception 15657 } catch (RecognitionException re) { 15658 System.err.println("impossible: "+re); 15659 } 15660 boolean success = !state.failed; 15661 input.rewind(start); 15662 dbg.endBacktrack(state.backtracking, success); 15663 state.backtracking--; 15664 state.failed=false; 15665 return success; 15666 } synpred52_Java()15667 public final boolean synpred52_Java() { 15668 state.backtracking++; 15669 dbg.beginBacktrack(state.backtracking); 15670 int start = input.mark(); 15671 try { 15672 synpred52_Java_fragment(); // can never throw exception 15673 } catch (RecognitionException re) { 15674 System.err.println("impossible: "+re); 15675 } 15676 boolean success = !state.failed; 15677 input.rewind(start); 15678 dbg.endBacktrack(state.backtracking, success); 15679 state.backtracking--; 15680 state.failed=false; 15681 return success; 15682 } synpred236_Java()15683 public final boolean synpred236_Java() { 15684 state.backtracking++; 15685 dbg.beginBacktrack(state.backtracking); 15686 int start = input.mark(); 15687 try { 15688 synpred236_Java_fragment(); // can never throw exception 15689 } catch (RecognitionException re) { 15690 System.err.println("impossible: "+re); 15691 } 15692 boolean success = !state.failed; 15693 input.rewind(start); 15694 dbg.endBacktrack(state.backtracking, success); 15695 state.backtracking--; 15696 state.failed=false; 15697 return success; 15698 } synpred12_Java()15699 public final boolean synpred12_Java() { 15700 state.backtracking++; 15701 dbg.beginBacktrack(state.backtracking); 15702 int start = input.mark(); 15703 try { 15704 synpred12_Java_fragment(); // can never throw exception 15705 } catch (RecognitionException re) { 15706 System.err.println("impossible: "+re); 15707 } 15708 boolean success = !state.failed; 15709 input.rewind(start); 15710 dbg.endBacktrack(state.backtracking, success); 15711 state.backtracking--; 15712 state.failed=false; 15713 return success; 15714 } synpred149_Java()15715 public final boolean synpred149_Java() { 15716 state.backtracking++; 15717 dbg.beginBacktrack(state.backtracking); 15718 int start = input.mark(); 15719 try { 15720 synpred149_Java_fragment(); // can never throw exception 15721 } catch (RecognitionException re) { 15722 System.err.println("impossible: "+re); 15723 } 15724 boolean success = !state.failed; 15725 input.rewind(start); 15726 dbg.endBacktrack(state.backtracking, success); 15727 state.backtracking--; 15728 state.failed=false; 15729 return success; 15730 } synpred120_Java()15731 public final boolean synpred120_Java() { 15732 state.backtracking++; 15733 dbg.beginBacktrack(state.backtracking); 15734 int start = input.mark(); 15735 try { 15736 synpred120_Java_fragment(); // can never throw exception 15737 } catch (RecognitionException re) { 15738 System.err.println("impossible: "+re); 15739 } 15740 boolean success = !state.failed; 15741 input.rewind(start); 15742 dbg.endBacktrack(state.backtracking, success); 15743 state.backtracking--; 15744 state.failed=false; 15745 return success; 15746 } synpred122_Java()15747 public final boolean synpred122_Java() { 15748 state.backtracking++; 15749 dbg.beginBacktrack(state.backtracking); 15750 int start = input.mark(); 15751 try { 15752 synpred122_Java_fragment(); // can never throw exception 15753 } catch (RecognitionException re) { 15754 System.err.println("impossible: "+re); 15755 } 15756 boolean success = !state.failed; 15757 input.rewind(start); 15758 dbg.endBacktrack(state.backtracking, success); 15759 state.backtracking--; 15760 state.failed=false; 15761 return success; 15762 } synpred240_Java()15763 public final boolean synpred240_Java() { 15764 state.backtracking++; 15765 dbg.beginBacktrack(state.backtracking); 15766 int start = input.mark(); 15767 try { 15768 synpred240_Java_fragment(); // can never throw exception 15769 } catch (RecognitionException re) { 15770 System.err.println("impossible: "+re); 15771 } 15772 boolean success = !state.failed; 15773 input.rewind(start); 15774 dbg.endBacktrack(state.backtracking, success); 15775 state.backtracking--; 15776 state.failed=false; 15777 return success; 15778 } synpred206_Java()15779 public final boolean synpred206_Java() { 15780 state.backtracking++; 15781 dbg.beginBacktrack(state.backtracking); 15782 int start = input.mark(); 15783 try { 15784 synpred206_Java_fragment(); // can never throw exception 15785 } catch (RecognitionException re) { 15786 System.err.println("impossible: "+re); 15787 } 15788 boolean success = !state.failed; 15789 input.rewind(start); 15790 dbg.endBacktrack(state.backtracking, success); 15791 state.backtracking--; 15792 state.failed=false; 15793 return success; 15794 } synpred70_Java()15795 public final boolean synpred70_Java() { 15796 state.backtracking++; 15797 dbg.beginBacktrack(state.backtracking); 15798 int start = input.mark(); 15799 try { 15800 synpred70_Java_fragment(); // can never throw exception 15801 } catch (RecognitionException re) { 15802 System.err.println("impossible: "+re); 15803 } 15804 boolean success = !state.failed; 15805 input.rewind(start); 15806 dbg.endBacktrack(state.backtracking, success); 15807 state.backtracking--; 15808 state.failed=false; 15809 return success; 15810 } synpred27_Java()15811 public final boolean synpred27_Java() { 15812 state.backtracking++; 15813 dbg.beginBacktrack(state.backtracking); 15814 int start = input.mark(); 15815 try { 15816 synpred27_Java_fragment(); // can never throw exception 15817 } catch (RecognitionException re) { 15818 System.err.println("impossible: "+re); 15819 } 15820 boolean success = !state.failed; 15821 input.rewind(start); 15822 dbg.endBacktrack(state.backtracking, success); 15823 state.backtracking--; 15824 state.failed=false; 15825 return success; 15826 } synpred96_Java()15827 public final boolean synpred96_Java() { 15828 state.backtracking++; 15829 dbg.beginBacktrack(state.backtracking); 15830 int start = input.mark(); 15831 try { 15832 synpred96_Java_fragment(); // can never throw exception 15833 } catch (RecognitionException re) { 15834 System.err.println("impossible: "+re); 15835 } 15836 boolean success = !state.failed; 15837 input.rewind(start); 15838 dbg.endBacktrack(state.backtracking, success); 15839 state.backtracking--; 15840 state.failed=false; 15841 return success; 15842 } synpred153_Java()15843 public final boolean synpred153_Java() { 15844 state.backtracking++; 15845 dbg.beginBacktrack(state.backtracking); 15846 int start = input.mark(); 15847 try { 15848 synpred153_Java_fragment(); // can never throw exception 15849 } catch (RecognitionException re) { 15850 System.err.println("impossible: "+re); 15851 } 15852 boolean success = !state.failed; 15853 input.rewind(start); 15854 dbg.endBacktrack(state.backtracking, success); 15855 state.backtracking--; 15856 state.failed=false; 15857 return success; 15858 } synpred99_Java()15859 public final boolean synpred99_Java() { 15860 state.backtracking++; 15861 dbg.beginBacktrack(state.backtracking); 15862 int start = input.mark(); 15863 try { 15864 synpred99_Java_fragment(); // can never throw exception 15865 } catch (RecognitionException re) { 15866 System.err.println("impossible: "+re); 15867 } 15868 boolean success = !state.failed; 15869 input.rewind(start); 15870 dbg.endBacktrack(state.backtracking, success); 15871 state.backtracking--; 15872 state.failed=false; 15873 return success; 15874 } synpred103_Java()15875 public final boolean synpred103_Java() { 15876 state.backtracking++; 15877 dbg.beginBacktrack(state.backtracking); 15878 int start = input.mark(); 15879 try { 15880 synpred103_Java_fragment(); // can never throw exception 15881 } catch (RecognitionException re) { 15882 System.err.println("impossible: "+re); 15883 } 15884 boolean success = !state.failed; 15885 input.rewind(start); 15886 dbg.endBacktrack(state.backtracking, success); 15887 state.backtracking--; 15888 state.failed=false; 15889 return success; 15890 } synpred237_Java()15891 public final boolean synpred237_Java() { 15892 state.backtracking++; 15893 dbg.beginBacktrack(state.backtracking); 15894 int start = input.mark(); 15895 try { 15896 synpred237_Java_fragment(); // can never throw exception 15897 } catch (RecognitionException re) { 15898 System.err.println("impossible: "+re); 15899 } 15900 boolean success = !state.failed; 15901 input.rewind(start); 15902 dbg.endBacktrack(state.backtracking, success); 15903 state.backtracking--; 15904 state.failed=false; 15905 return success; 15906 } synpred118_Java()15907 public final boolean synpred118_Java() { 15908 state.backtracking++; 15909 dbg.beginBacktrack(state.backtracking); 15910 int start = input.mark(); 15911 try { 15912 synpred118_Java_fragment(); // can never throw exception 15913 } catch (RecognitionException re) { 15914 System.err.println("impossible: "+re); 15915 } 15916 boolean success = !state.failed; 15917 input.rewind(start); 15918 dbg.endBacktrack(state.backtracking, success); 15919 state.backtracking--; 15920 state.failed=false; 15921 return success; 15922 } synpred208_Java()15923 public final boolean synpred208_Java() { 15924 state.backtracking++; 15925 dbg.beginBacktrack(state.backtracking); 15926 int start = input.mark(); 15927 try { 15928 synpred208_Java_fragment(); // can never throw exception 15929 } catch (RecognitionException re) { 15930 System.err.println("impossible: "+re); 15931 } 15932 boolean success = !state.failed; 15933 input.rewind(start); 15934 dbg.endBacktrack(state.backtracking, success); 15935 state.backtracking--; 15936 state.failed=false; 15937 return success; 15938 } 15939 15940 15941 protected DFA2 dfa2 = new DFA2(this); 15942 protected DFA12 dfa12 = new DFA12(this); 15943 protected DFA13 dfa13 = new DFA13(this); 15944 protected DFA15 dfa15 = new DFA15(this); 15945 protected DFA31 dfa31 = new DFA31(this); 15946 protected DFA39 dfa39 = new DFA39(this); 15947 protected DFA49 dfa49 = new DFA49(this); 15948 protected DFA42 dfa42 = new DFA42(this); 15949 protected DFA53 dfa53 = new DFA53(this); 15950 protected DFA76 dfa76 = new DFA76(this); 15951 protected DFA87 dfa87 = new DFA87(this); 15952 protected DFA90 dfa90 = new DFA90(this); 15953 protected DFA98 dfa98 = new DFA98(this); 15954 protected DFA109 dfa109 = new DFA109(this); 15955 protected DFA112 dfa112 = new DFA112(this); 15956 protected DFA130 dfa130 = new DFA130(this); 15957 protected DFA133 dfa133 = new DFA133(this); 15958 protected DFA135 dfa135 = new DFA135(this); 15959 protected DFA143 dfa143 = new DFA143(this); 15960 protected DFA142 dfa142 = new DFA142(this); 15961 protected DFA148 dfa148 = new DFA148(this); 15962 protected DFA171 dfa171 = new DFA171(this); 15963 static final String DFA2_eotS = 15964 "\24\uffff"; 15965 static final String DFA2_eofS = 15966 "\1\3\23\uffff"; 15967 static final String DFA2_minS = 15968 "\1\34\1\0\22\uffff"; 15969 static final String DFA2_maxS = 15970 "\1\162\1\0\22\uffff"; 15971 static final String DFA2_acceptS = 15972 "\2\uffff\1\1\1\2\20\uffff"; 15973 static final String DFA2_specialS = 15974 "\1\uffff\1\0\22\uffff}>"; 15975 static final String[] DFA2_transitionS = { 15976 "\1\3\7\uffff\1\3\6\uffff\1\3\1\uffff\1\3\6\uffff\1\3\2\uffff"+ 15977 "\1\3\1\uffff\1\3\1\uffff\1\2\3\3\2\uffff\2\3\2\uffff\1\3\3\uffff"+ 15978 "\1\3\2\uffff\1\3\7\uffff\1\3\35\uffff\1\1", 15979 "\1\uffff", 15980 "", 15981 "", 15982 "", 15983 "", 15984 "", 15985 "", 15986 "", 15987 "", 15988 "", 15989 "", 15990 "", 15991 "", 15992 "", 15993 "", 15994 "", 15995 "", 15996 "", 15997 "" 15998 }; 15999 16000 static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS); 16001 static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS); 16002 static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS); 16003 static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS); 16004 static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS); 16005 static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS); 16006 static final short[][] DFA2_transition; 16007 16008 static { 16009 int numStates = DFA2_transitionS.length; 16010 DFA2_transition = new short[numStates][]; 16011 for (int i=0; i<numStates; i++) { 16012 DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]); 16013 } 16014 } 16015 16016 class DFA2 extends DFA { 16017 DFA2(BaseRecognizer recognizer)16018 public DFA2(BaseRecognizer recognizer) { 16019 this.recognizer = recognizer; 16020 this.decisionNumber = 2; 16021 this.eot = DFA2_eot; 16022 this.eof = DFA2_eof; 16023 this.min = DFA2_min; 16024 this.max = DFA2_max; 16025 this.accept = DFA2_accept; 16026 this.special = DFA2_special; 16027 this.transition = DFA2_transition; 16028 } getDescription()16029 public String getDescription() { 16030 return "298:9: ( ( annotations )? packageDeclaration )?"; 16031 } error(NoViableAltException nvae)16032 public void error(NoViableAltException nvae) { 16033 dbg.recognitionException(nvae); 16034 } specialStateTransition(int s, IntStream _input)16035 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 16036 TokenStream input = (TokenStream)_input; 16037 int _s = s; 16038 switch ( s ) { 16039 case 0 : 16040 int LA2_1 = input.LA(1); 16041 16042 16043 int index2_1 = input.index(); 16044 input.rewind(); 16045 s = -1; 16046 if ( (synpred2_Java()) ) {s = 2;} 16047 16048 else if ( (true) ) {s = 3;} 16049 16050 16051 input.seek(index2_1); 16052 if ( s>=0 ) return s; 16053 break; 16054 } 16055 if (state.backtracking>0) {state.failed=true; return -1;} 16056 NoViableAltException nvae = 16057 new NoViableAltException(getDescription(), 2, _s, input); 16058 error(nvae); 16059 throw nvae; 16060 } 16061 } 16062 static final String DFA12_eotS = 16063 "\20\uffff"; 16064 static final String DFA12_eofS = 16065 "\20\uffff"; 16066 static final String DFA12_minS = 16067 "\1\34\14\0\3\uffff"; 16068 static final String DFA12_maxS = 16069 "\1\162\14\0\3\uffff"; 16070 static final String DFA12_acceptS = 16071 "\15\uffff\1\1\1\uffff\1\2"; 16072 static final String DFA12_specialS = 16073 "\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}>"; 16074 static final String[] DFA12_transitionS = { 16075 "\1\6\7\uffff\1\15\6\uffff\1\15\1\uffff\1\7\11\uffff\1\17\1\uffff"+ 16076 "\1\10\2\uffff\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff"+ 16077 "\1\12\2\uffff\1\13\45\uffff\1\1", 16078 "\1\uffff", 16079 "\1\uffff", 16080 "\1\uffff", 16081 "\1\uffff", 16082 "\1\uffff", 16083 "\1\uffff", 16084 "\1\uffff", 16085 "\1\uffff", 16086 "\1\uffff", 16087 "\1\uffff", 16088 "\1\uffff", 16089 "\1\uffff", 16090 "", 16091 "", 16092 "" 16093 }; 16094 16095 static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS); 16096 static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS); 16097 static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS); 16098 static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS); 16099 static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS); 16100 static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS); 16101 static final short[][] DFA12_transition; 16102 16103 static { 16104 int numStates = DFA12_transitionS.length; 16105 DFA12_transition = new short[numStates][]; 16106 for (int i=0; i<numStates; i++) { 16107 DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]); 16108 } 16109 } 16110 16111 class DFA12 extends DFA { 16112 DFA12(BaseRecognizer recognizer)16113 public DFA12(BaseRecognizer recognizer) { 16114 this.recognizer = recognizer; 16115 this.decisionNumber = 12; 16116 this.eot = DFA12_eot; 16117 this.eof = DFA12_eof; 16118 this.min = DFA12_min; 16119 this.max = DFA12_max; 16120 this.accept = DFA12_accept; 16121 this.special = DFA12_special; 16122 this.transition = DFA12_transition; 16123 } getDescription()16124 public String getDescription() { 16125 return "341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );"; 16126 } error(NoViableAltException nvae)16127 public void error(NoViableAltException nvae) { 16128 dbg.recognitionException(nvae); 16129 } specialStateTransition(int s, IntStream _input)16130 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 16131 TokenStream input = (TokenStream)_input; 16132 int _s = s; 16133 switch ( s ) { 16134 case 0 : 16135 int LA12_1 = input.LA(1); 16136 16137 16138 int index12_1 = input.index(); 16139 input.rewind(); 16140 s = -1; 16141 if ( (synpred12_Java()) ) {s = 13;} 16142 16143 else if ( (true) ) {s = 15;} 16144 16145 16146 input.seek(index12_1); 16147 if ( s>=0 ) return s; 16148 break; 16149 case 1 : 16150 int LA12_2 = input.LA(1); 16151 16152 16153 int index12_2 = input.index(); 16154 input.rewind(); 16155 s = -1; 16156 if ( (synpred12_Java()) ) {s = 13;} 16157 16158 else if ( (true) ) {s = 15;} 16159 16160 16161 input.seek(index12_2); 16162 if ( s>=0 ) return s; 16163 break; 16164 case 2 : 16165 int LA12_3 = input.LA(1); 16166 16167 16168 int index12_3 = input.index(); 16169 input.rewind(); 16170 s = -1; 16171 if ( (synpred12_Java()) ) {s = 13;} 16172 16173 else if ( (true) ) {s = 15;} 16174 16175 16176 input.seek(index12_3); 16177 if ( s>=0 ) return s; 16178 break; 16179 case 3 : 16180 int LA12_4 = input.LA(1); 16181 16182 16183 int index12_4 = input.index(); 16184 input.rewind(); 16185 s = -1; 16186 if ( (synpred12_Java()) ) {s = 13;} 16187 16188 else if ( (true) ) {s = 15;} 16189 16190 16191 input.seek(index12_4); 16192 if ( s>=0 ) return s; 16193 break; 16194 case 4 : 16195 int LA12_5 = input.LA(1); 16196 16197 16198 int index12_5 = input.index(); 16199 input.rewind(); 16200 s = -1; 16201 if ( (synpred12_Java()) ) {s = 13;} 16202 16203 else if ( (true) ) {s = 15;} 16204 16205 16206 input.seek(index12_5); 16207 if ( s>=0 ) return s; 16208 break; 16209 case 5 : 16210 int LA12_6 = input.LA(1); 16211 16212 16213 int index12_6 = input.index(); 16214 input.rewind(); 16215 s = -1; 16216 if ( (synpred12_Java()) ) {s = 13;} 16217 16218 else if ( (true) ) {s = 15;} 16219 16220 16221 input.seek(index12_6); 16222 if ( s>=0 ) return s; 16223 break; 16224 case 6 : 16225 int LA12_7 = input.LA(1); 16226 16227 16228 int index12_7 = input.index(); 16229 input.rewind(); 16230 s = -1; 16231 if ( (synpred12_Java()) ) {s = 13;} 16232 16233 else if ( (true) ) {s = 15;} 16234 16235 16236 input.seek(index12_7); 16237 if ( s>=0 ) return s; 16238 break; 16239 case 7 : 16240 int LA12_8 = input.LA(1); 16241 16242 16243 int index12_8 = input.index(); 16244 input.rewind(); 16245 s = -1; 16246 if ( (synpred12_Java()) ) {s = 13;} 16247 16248 else if ( (true) ) {s = 15;} 16249 16250 16251 input.seek(index12_8); 16252 if ( s>=0 ) return s; 16253 break; 16254 case 8 : 16255 int LA12_9 = input.LA(1); 16256 16257 16258 int index12_9 = input.index(); 16259 input.rewind(); 16260 s = -1; 16261 if ( (synpred12_Java()) ) {s = 13;} 16262 16263 else if ( (true) ) {s = 15;} 16264 16265 16266 input.seek(index12_9); 16267 if ( s>=0 ) return s; 16268 break; 16269 case 9 : 16270 int LA12_10 = input.LA(1); 16271 16272 16273 int index12_10 = input.index(); 16274 input.rewind(); 16275 s = -1; 16276 if ( (synpred12_Java()) ) {s = 13;} 16277 16278 else if ( (true) ) {s = 15;} 16279 16280 16281 input.seek(index12_10); 16282 if ( s>=0 ) return s; 16283 break; 16284 case 10 : 16285 int LA12_11 = input.LA(1); 16286 16287 16288 int index12_11 = input.index(); 16289 input.rewind(); 16290 s = -1; 16291 if ( (synpred12_Java()) ) {s = 13;} 16292 16293 else if ( (true) ) {s = 15;} 16294 16295 16296 input.seek(index12_11); 16297 if ( s>=0 ) return s; 16298 break; 16299 case 11 : 16300 int LA12_12 = input.LA(1); 16301 16302 16303 int index12_12 = input.index(); 16304 input.rewind(); 16305 s = -1; 16306 if ( (synpred12_Java()) ) {s = 13;} 16307 16308 else if ( (true) ) {s = 15;} 16309 16310 16311 input.seek(index12_12); 16312 if ( s>=0 ) return s; 16313 break; 16314 } 16315 if (state.backtracking>0) {state.failed=true; return -1;} 16316 NoViableAltException nvae = 16317 new NoViableAltException(getDescription(), 12, _s, input); 16318 error(nvae); 16319 throw nvae; 16320 } 16321 } 16322 static final String DFA13_eotS = 16323 "\17\uffff"; 16324 static final String DFA13_eofS = 16325 "\17\uffff"; 16326 static final String DFA13_minS = 16327 "\1\4\1\uffff\1\4\14\uffff"; 16328 static final String DFA13_maxS = 16329 "\1\165\1\uffff\1\67\14\uffff"; 16330 static final String DFA13_acceptS = 16331 "\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"+ 16332 "\1\14\1\1"; 16333 static final String DFA13_specialS = 16334 "\17\uffff}>"; 16335 static final String[] DFA13_transitionS = { 16336 "\1\1\27\uffff\1\7\1\uffff\1\1\1\uffff\1\1\2\uffff\2\1\4\uffff"+ 16337 "\1\1\1\uffff\1\1\1\uffff\1\10\1\uffff\1\1\6\uffff\3\1\1\11\2"+ 16338 "\uffff\1\5\1\4\1\3\1\uffff\1\1\1\6\1\15\2\uffff\1\12\3\uffff"+ 16339 "\1\13\1\uffff\1\1\1\14\45\uffff\1\2\2\uffff\1\1", 16340 "", 16341 "\1\16\62\uffff\1\1", 16342 "", 16343 "", 16344 "", 16345 "", 16346 "", 16347 "", 16348 "", 16349 "", 16350 "", 16351 "", 16352 "", 16353 "" 16354 }; 16355 16356 static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS); 16357 static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS); 16358 static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS); 16359 static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS); 16360 static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS); 16361 static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS); 16362 static final short[][] DFA13_transition; 16363 16364 static { 16365 int numStates = DFA13_transitionS.length; 16366 DFA13_transition = new short[numStates][]; 16367 for (int i=0; i<numStates; i++) { 16368 DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]); 16369 } 16370 } 16371 16372 class DFA13 extends DFA { 16373 DFA13(BaseRecognizer recognizer)16374 public DFA13(BaseRecognizer recognizer) { 16375 this.recognizer = recognizer; 16376 this.decisionNumber = 13; 16377 this.eot = DFA13_eot; 16378 this.eof = DFA13_eof; 16379 this.min = DFA13_min; 16380 this.max = DFA13_max; 16381 this.accept = DFA13_accept; 16382 this.special = DFA13_special; 16383 this.transition = DFA13_transition; 16384 } getDescription()16385 public String getDescription() { 16386 return "()* loopback of 349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*"; 16387 } error(NoViableAltException nvae)16388 public void error(NoViableAltException nvae) { 16389 dbg.recognitionException(nvae); 16390 } 16391 } 16392 static final String DFA15_eotS = 16393 "\17\uffff"; 16394 static final String DFA15_eofS = 16395 "\17\uffff"; 16396 static final String DFA15_minS = 16397 "\1\34\14\0\2\uffff"; 16398 static final String DFA15_maxS = 16399 "\1\162\14\0\2\uffff"; 16400 static final String DFA15_acceptS = 16401 "\15\uffff\1\1\1\2"; 16402 static final String DFA15_specialS = 16403 "\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}>"; 16404 static final String[] DFA15_transitionS = { 16405 "\1\6\7\uffff\1\15\6\uffff\1\16\1\uffff\1\7\13\uffff\1\10\2\uffff"+ 16406 "\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff"+ 16407 "\1\13\45\uffff\1\1", 16408 "\1\uffff", 16409 "\1\uffff", 16410 "\1\uffff", 16411 "\1\uffff", 16412 "\1\uffff", 16413 "\1\uffff", 16414 "\1\uffff", 16415 "\1\uffff", 16416 "\1\uffff", 16417 "\1\uffff", 16418 "\1\uffff", 16419 "\1\uffff", 16420 "", 16421 "" 16422 }; 16423 16424 static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS); 16425 static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS); 16426 static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS); 16427 static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS); 16428 static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS); 16429 static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS); 16430 static final short[][] DFA15_transition; 16431 16432 static { 16433 int numStates = DFA15_transitionS.length; 16434 DFA15_transition = new short[numStates][]; 16435 for (int i=0; i<numStates; i++) { 16436 DFA15_transition[i] = DFA.unpackEncodedString(DFA15_transitionS[i]); 16437 } 16438 } 16439 16440 class DFA15 extends DFA { 16441 DFA15(BaseRecognizer recognizer)16442 public DFA15(BaseRecognizer recognizer) { 16443 this.recognizer = recognizer; 16444 this.decisionNumber = 15; 16445 this.eot = DFA15_eot; 16446 this.eof = DFA15_eof; 16447 this.min = DFA15_min; 16448 this.max = DFA15_max; 16449 this.accept = DFA15_accept; 16450 this.special = DFA15_special; 16451 this.transition = DFA15_transition; 16452 } getDescription()16453 public String getDescription() { 16454 return "372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );"; 16455 } error(NoViableAltException nvae)16456 public void error(NoViableAltException nvae) { 16457 dbg.recognitionException(nvae); 16458 } specialStateTransition(int s, IntStream _input)16459 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 16460 TokenStream input = (TokenStream)_input; 16461 int _s = s; 16462 switch ( s ) { 16463 case 0 : 16464 int LA15_1 = input.LA(1); 16465 16466 16467 int index15_1 = input.index(); 16468 input.rewind(); 16469 s = -1; 16470 if ( (synpred27_Java()) ) {s = 13;} 16471 16472 else if ( (true) ) {s = 14;} 16473 16474 16475 input.seek(index15_1); 16476 if ( s>=0 ) return s; 16477 break; 16478 case 1 : 16479 int LA15_2 = input.LA(1); 16480 16481 16482 int index15_2 = input.index(); 16483 input.rewind(); 16484 s = -1; 16485 if ( (synpred27_Java()) ) {s = 13;} 16486 16487 else if ( (true) ) {s = 14;} 16488 16489 16490 input.seek(index15_2); 16491 if ( s>=0 ) return s; 16492 break; 16493 case 2 : 16494 int LA15_3 = input.LA(1); 16495 16496 16497 int index15_3 = input.index(); 16498 input.rewind(); 16499 s = -1; 16500 if ( (synpred27_Java()) ) {s = 13;} 16501 16502 else if ( (true) ) {s = 14;} 16503 16504 16505 input.seek(index15_3); 16506 if ( s>=0 ) return s; 16507 break; 16508 case 3 : 16509 int LA15_4 = input.LA(1); 16510 16511 16512 int index15_4 = input.index(); 16513 input.rewind(); 16514 s = -1; 16515 if ( (synpred27_Java()) ) {s = 13;} 16516 16517 else if ( (true) ) {s = 14;} 16518 16519 16520 input.seek(index15_4); 16521 if ( s>=0 ) return s; 16522 break; 16523 case 4 : 16524 int LA15_5 = input.LA(1); 16525 16526 16527 int index15_5 = input.index(); 16528 input.rewind(); 16529 s = -1; 16530 if ( (synpred27_Java()) ) {s = 13;} 16531 16532 else if ( (true) ) {s = 14;} 16533 16534 16535 input.seek(index15_5); 16536 if ( s>=0 ) return s; 16537 break; 16538 case 5 : 16539 int LA15_6 = input.LA(1); 16540 16541 16542 int index15_6 = input.index(); 16543 input.rewind(); 16544 s = -1; 16545 if ( (synpred27_Java()) ) {s = 13;} 16546 16547 else if ( (true) ) {s = 14;} 16548 16549 16550 input.seek(index15_6); 16551 if ( s>=0 ) return s; 16552 break; 16553 case 6 : 16554 int LA15_7 = input.LA(1); 16555 16556 16557 int index15_7 = input.index(); 16558 input.rewind(); 16559 s = -1; 16560 if ( (synpred27_Java()) ) {s = 13;} 16561 16562 else if ( (true) ) {s = 14;} 16563 16564 16565 input.seek(index15_7); 16566 if ( s>=0 ) return s; 16567 break; 16568 case 7 : 16569 int LA15_8 = input.LA(1); 16570 16571 16572 int index15_8 = input.index(); 16573 input.rewind(); 16574 s = -1; 16575 if ( (synpred27_Java()) ) {s = 13;} 16576 16577 else if ( (true) ) {s = 14;} 16578 16579 16580 input.seek(index15_8); 16581 if ( s>=0 ) return s; 16582 break; 16583 case 8 : 16584 int LA15_9 = input.LA(1); 16585 16586 16587 int index15_9 = input.index(); 16588 input.rewind(); 16589 s = -1; 16590 if ( (synpred27_Java()) ) {s = 13;} 16591 16592 else if ( (true) ) {s = 14;} 16593 16594 16595 input.seek(index15_9); 16596 if ( s>=0 ) return s; 16597 break; 16598 case 9 : 16599 int LA15_10 = input.LA(1); 16600 16601 16602 int index15_10 = input.index(); 16603 input.rewind(); 16604 s = -1; 16605 if ( (synpred27_Java()) ) {s = 13;} 16606 16607 else if ( (true) ) {s = 14;} 16608 16609 16610 input.seek(index15_10); 16611 if ( s>=0 ) return s; 16612 break; 16613 case 10 : 16614 int LA15_11 = input.LA(1); 16615 16616 16617 int index15_11 = input.index(); 16618 input.rewind(); 16619 s = -1; 16620 if ( (synpred27_Java()) ) {s = 13;} 16621 16622 else if ( (true) ) {s = 14;} 16623 16624 16625 input.seek(index15_11); 16626 if ( s>=0 ) return s; 16627 break; 16628 case 11 : 16629 int LA15_12 = input.LA(1); 16630 16631 16632 int index15_12 = input.index(); 16633 input.rewind(); 16634 s = -1; 16635 if ( (synpred27_Java()) ) {s = 13;} 16636 16637 else if ( (true) ) {s = 14;} 16638 16639 16640 input.seek(index15_12); 16641 if ( s>=0 ) return s; 16642 break; 16643 } 16644 if (state.backtracking>0) {state.failed=true; return -1;} 16645 NoViableAltException nvae = 16646 new NoViableAltException(getDescription(), 15, _s, input); 16647 error(nvae); 16648 throw nvae; 16649 } 16650 } 16651 static final String DFA31_eotS = 16652 "\17\uffff"; 16653 static final String DFA31_eofS = 16654 "\17\uffff"; 16655 static final String DFA31_minS = 16656 "\1\34\14\0\2\uffff"; 16657 static final String DFA31_maxS = 16658 "\1\162\14\0\2\uffff"; 16659 static final String DFA31_acceptS = 16660 "\15\uffff\1\1\1\2"; 16661 static final String DFA31_specialS = 16662 "\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}>"; 16663 static final String[] DFA31_transitionS = { 16664 "\1\6\20\uffff\1\7\11\uffff\1\15\1\uffff\1\10\2\uffff\1\4\1\3"+ 16665 "\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13"+ 16666 "\45\uffff\1\1", 16667 "\1\uffff", 16668 "\1\uffff", 16669 "\1\uffff", 16670 "\1\uffff", 16671 "\1\uffff", 16672 "\1\uffff", 16673 "\1\uffff", 16674 "\1\uffff", 16675 "\1\uffff", 16676 "\1\uffff", 16677 "\1\uffff", 16678 "\1\uffff", 16679 "", 16680 "" 16681 }; 16682 16683 static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS); 16684 static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS); 16685 static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS); 16686 static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS); 16687 static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS); 16688 static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS); 16689 static final short[][] DFA31_transition; 16690 16691 static { 16692 int numStates = DFA31_transitionS.length; 16693 DFA31_transition = new short[numStates][]; 16694 for (int i=0; i<numStates; i++) { 16695 DFA31_transition[i] = DFA.unpackEncodedString(DFA31_transitionS[i]); 16696 } 16697 } 16698 16699 class DFA31 extends DFA { 16700 DFA31(BaseRecognizer recognizer)16701 public DFA31(BaseRecognizer recognizer) { 16702 this.recognizer = recognizer; 16703 this.decisionNumber = 31; 16704 this.eot = DFA31_eot; 16705 this.eof = DFA31_eof; 16706 this.min = DFA31_min; 16707 this.max = DFA31_max; 16708 this.accept = DFA31_accept; 16709 this.special = DFA31_special; 16710 this.transition = DFA31_transition; 16711 } getDescription()16712 public String getDescription() { 16713 return "460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );"; 16714 } error(NoViableAltException nvae)16715 public void error(NoViableAltException nvae) { 16716 dbg.recognitionException(nvae); 16717 } specialStateTransition(int s, IntStream _input)16718 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 16719 TokenStream input = (TokenStream)_input; 16720 int _s = s; 16721 switch ( s ) { 16722 case 0 : 16723 int LA31_1 = input.LA(1); 16724 16725 16726 int index31_1 = input.index(); 16727 input.rewind(); 16728 s = -1; 16729 if ( (synpred43_Java()) ) {s = 13;} 16730 16731 else if ( (true) ) {s = 14;} 16732 16733 16734 input.seek(index31_1); 16735 if ( s>=0 ) return s; 16736 break; 16737 case 1 : 16738 int LA31_2 = input.LA(1); 16739 16740 16741 int index31_2 = input.index(); 16742 input.rewind(); 16743 s = -1; 16744 if ( (synpred43_Java()) ) {s = 13;} 16745 16746 else if ( (true) ) {s = 14;} 16747 16748 16749 input.seek(index31_2); 16750 if ( s>=0 ) return s; 16751 break; 16752 case 2 : 16753 int LA31_3 = input.LA(1); 16754 16755 16756 int index31_3 = input.index(); 16757 input.rewind(); 16758 s = -1; 16759 if ( (synpred43_Java()) ) {s = 13;} 16760 16761 else if ( (true) ) {s = 14;} 16762 16763 16764 input.seek(index31_3); 16765 if ( s>=0 ) return s; 16766 break; 16767 case 3 : 16768 int LA31_4 = input.LA(1); 16769 16770 16771 int index31_4 = input.index(); 16772 input.rewind(); 16773 s = -1; 16774 if ( (synpred43_Java()) ) {s = 13;} 16775 16776 else if ( (true) ) {s = 14;} 16777 16778 16779 input.seek(index31_4); 16780 if ( s>=0 ) return s; 16781 break; 16782 case 4 : 16783 int LA31_5 = input.LA(1); 16784 16785 16786 int index31_5 = input.index(); 16787 input.rewind(); 16788 s = -1; 16789 if ( (synpred43_Java()) ) {s = 13;} 16790 16791 else if ( (true) ) {s = 14;} 16792 16793 16794 input.seek(index31_5); 16795 if ( s>=0 ) return s; 16796 break; 16797 case 5 : 16798 int LA31_6 = input.LA(1); 16799 16800 16801 int index31_6 = input.index(); 16802 input.rewind(); 16803 s = -1; 16804 if ( (synpred43_Java()) ) {s = 13;} 16805 16806 else if ( (true) ) {s = 14;} 16807 16808 16809 input.seek(index31_6); 16810 if ( s>=0 ) return s; 16811 break; 16812 case 6 : 16813 int LA31_7 = input.LA(1); 16814 16815 16816 int index31_7 = input.index(); 16817 input.rewind(); 16818 s = -1; 16819 if ( (synpred43_Java()) ) {s = 13;} 16820 16821 else if ( (true) ) {s = 14;} 16822 16823 16824 input.seek(index31_7); 16825 if ( s>=0 ) return s; 16826 break; 16827 case 7 : 16828 int LA31_8 = input.LA(1); 16829 16830 16831 int index31_8 = input.index(); 16832 input.rewind(); 16833 s = -1; 16834 if ( (synpred43_Java()) ) {s = 13;} 16835 16836 else if ( (true) ) {s = 14;} 16837 16838 16839 input.seek(index31_8); 16840 if ( s>=0 ) return s; 16841 break; 16842 case 8 : 16843 int LA31_9 = input.LA(1); 16844 16845 16846 int index31_9 = input.index(); 16847 input.rewind(); 16848 s = -1; 16849 if ( (synpred43_Java()) ) {s = 13;} 16850 16851 else if ( (true) ) {s = 14;} 16852 16853 16854 input.seek(index31_9); 16855 if ( s>=0 ) return s; 16856 break; 16857 case 9 : 16858 int LA31_10 = input.LA(1); 16859 16860 16861 int index31_10 = input.index(); 16862 input.rewind(); 16863 s = -1; 16864 if ( (synpred43_Java()) ) {s = 13;} 16865 16866 else if ( (true) ) {s = 14;} 16867 16868 16869 input.seek(index31_10); 16870 if ( s>=0 ) return s; 16871 break; 16872 case 10 : 16873 int LA31_11 = input.LA(1); 16874 16875 16876 int index31_11 = input.index(); 16877 input.rewind(); 16878 s = -1; 16879 if ( (synpred43_Java()) ) {s = 13;} 16880 16881 else if ( (true) ) {s = 14;} 16882 16883 16884 input.seek(index31_11); 16885 if ( s>=0 ) return s; 16886 break; 16887 case 11 : 16888 int LA31_12 = input.LA(1); 16889 16890 16891 int index31_12 = input.index(); 16892 input.rewind(); 16893 s = -1; 16894 if ( (synpred43_Java()) ) {s = 13;} 16895 16896 else if ( (true) ) {s = 14;} 16897 16898 16899 input.seek(index31_12); 16900 if ( s>=0 ) return s; 16901 break; 16902 } 16903 if (state.backtracking>0) {state.failed=true; return -1;} 16904 NoViableAltException nvae = 16905 new NoViableAltException(getDescription(), 31, _s, input); 16906 error(nvae); 16907 throw nvae; 16908 } 16909 } 16910 static final String DFA39_eotS = 16911 "\25\uffff"; 16912 static final String DFA39_eofS = 16913 "\25\uffff"; 16914 static final String DFA39_minS = 16915 "\1\4\16\0\6\uffff"; 16916 static final String DFA39_maxS = 16917 "\1\165\16\0\6\uffff"; 16918 static final String DFA39_acceptS = 16919 "\17\uffff\1\2\1\uffff\1\3\1\uffff\1\4\1\1"; 16920 static final String DFA39_specialS = 16921 "\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"+ 16922 "\1\15\6\uffff}>"; 16923 static final String[] DFA39_transitionS = { 16924 "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+ 16925 "\21\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+ 16926 "\1\16\1\23\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+ 16927 "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1"+ 16928 "\2\uffff\1\17", 16929 "\1\uffff", 16930 "\1\uffff", 16931 "\1\uffff", 16932 "\1\uffff", 16933 "\1\uffff", 16934 "\1\uffff", 16935 "\1\uffff", 16936 "\1\uffff", 16937 "\1\uffff", 16938 "\1\uffff", 16939 "\1\uffff", 16940 "\1\uffff", 16941 "\1\uffff", 16942 "\1\uffff", 16943 "", 16944 "", 16945 "", 16946 "", 16947 "", 16948 "" 16949 }; 16950 16951 static final short[] DFA39_eot = DFA.unpackEncodedString(DFA39_eotS); 16952 static final short[] DFA39_eof = DFA.unpackEncodedString(DFA39_eofS); 16953 static final char[] DFA39_min = DFA.unpackEncodedStringToUnsignedChars(DFA39_minS); 16954 static final char[] DFA39_max = DFA.unpackEncodedStringToUnsignedChars(DFA39_maxS); 16955 static final short[] DFA39_accept = DFA.unpackEncodedString(DFA39_acceptS); 16956 static final short[] DFA39_special = DFA.unpackEncodedString(DFA39_specialS); 16957 static final short[][] DFA39_transition; 16958 16959 static { 16960 int numStates = DFA39_transitionS.length; 16961 DFA39_transition = new short[numStates][]; 16962 for (int i=0; i<numStates; i++) { 16963 DFA39_transition[i] = DFA.unpackEncodedString(DFA39_transitionS[i]); 16964 } 16965 } 16966 16967 class DFA39 extends DFA { 16968 DFA39(BaseRecognizer recognizer)16969 public DFA39(BaseRecognizer recognizer) { 16970 this.recognizer = recognizer; 16971 this.decisionNumber = 39; 16972 this.eot = DFA39_eot; 16973 this.eof = DFA39_eof; 16974 this.min = DFA39_min; 16975 this.max = DFA39_max; 16976 this.accept = DFA39_accept; 16977 this.special = DFA39_special; 16978 this.transition = DFA39_transition; 16979 } getDescription()16980 public String getDescription() { 16981 return "502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );"; 16982 } error(NoViableAltException nvae)16983 public void error(NoViableAltException nvae) { 16984 dbg.recognitionException(nvae); 16985 } specialStateTransition(int s, IntStream _input)16986 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 16987 TokenStream input = (TokenStream)_input; 16988 int _s = s; 16989 switch ( s ) { 16990 case 0 : 16991 int LA39_1 = input.LA(1); 16992 16993 16994 int index39_1 = input.index(); 16995 input.rewind(); 16996 s = -1; 16997 if ( (synpred52_Java()) ) {s = 20;} 16998 16999 else if ( (synpred53_Java()) ) {s = 15;} 17000 17001 else if ( (synpred54_Java()) ) {s = 17;} 17002 17003 else if ( (true) ) {s = 19;} 17004 17005 17006 input.seek(index39_1); 17007 if ( s>=0 ) return s; 17008 break; 17009 case 1 : 17010 int LA39_2 = input.LA(1); 17011 17012 17013 int index39_2 = input.index(); 17014 input.rewind(); 17015 s = -1; 17016 if ( (synpred52_Java()) ) {s = 20;} 17017 17018 else if ( (synpred53_Java()) ) {s = 15;} 17019 17020 else if ( (synpred54_Java()) ) {s = 17;} 17021 17022 else if ( (true) ) {s = 19;} 17023 17024 17025 input.seek(index39_2); 17026 if ( s>=0 ) return s; 17027 break; 17028 case 2 : 17029 int LA39_3 = input.LA(1); 17030 17031 17032 int index39_3 = input.index(); 17033 input.rewind(); 17034 s = -1; 17035 if ( (synpred52_Java()) ) {s = 20;} 17036 17037 else if ( (synpred53_Java()) ) {s = 15;} 17038 17039 else if ( (synpred54_Java()) ) {s = 17;} 17040 17041 else if ( (true) ) {s = 19;} 17042 17043 17044 input.seek(index39_3); 17045 if ( s>=0 ) return s; 17046 break; 17047 case 3 : 17048 int LA39_4 = input.LA(1); 17049 17050 17051 int index39_4 = input.index(); 17052 input.rewind(); 17053 s = -1; 17054 if ( (synpred52_Java()) ) {s = 20;} 17055 17056 else if ( (synpred53_Java()) ) {s = 15;} 17057 17058 else if ( (synpred54_Java()) ) {s = 17;} 17059 17060 else if ( (true) ) {s = 19;} 17061 17062 17063 input.seek(index39_4); 17064 if ( s>=0 ) return s; 17065 break; 17066 case 4 : 17067 int LA39_5 = input.LA(1); 17068 17069 17070 int index39_5 = input.index(); 17071 input.rewind(); 17072 s = -1; 17073 if ( (synpred52_Java()) ) {s = 20;} 17074 17075 else if ( (synpred53_Java()) ) {s = 15;} 17076 17077 else if ( (synpred54_Java()) ) {s = 17;} 17078 17079 else if ( (true) ) {s = 19;} 17080 17081 17082 input.seek(index39_5); 17083 if ( s>=0 ) return s; 17084 break; 17085 case 5 : 17086 int LA39_6 = input.LA(1); 17087 17088 17089 int index39_6 = input.index(); 17090 input.rewind(); 17091 s = -1; 17092 if ( (synpred52_Java()) ) {s = 20;} 17093 17094 else if ( (synpred53_Java()) ) {s = 15;} 17095 17096 else if ( (synpred54_Java()) ) {s = 17;} 17097 17098 else if ( (true) ) {s = 19;} 17099 17100 17101 input.seek(index39_6); 17102 if ( s>=0 ) return s; 17103 break; 17104 case 6 : 17105 int LA39_7 = input.LA(1); 17106 17107 17108 int index39_7 = input.index(); 17109 input.rewind(); 17110 s = -1; 17111 if ( (synpred52_Java()) ) {s = 20;} 17112 17113 else if ( (synpred53_Java()) ) {s = 15;} 17114 17115 else if ( (synpred54_Java()) ) {s = 17;} 17116 17117 else if ( (true) ) {s = 19;} 17118 17119 17120 input.seek(index39_7); 17121 if ( s>=0 ) return s; 17122 break; 17123 case 7 : 17124 int LA39_8 = input.LA(1); 17125 17126 17127 int index39_8 = input.index(); 17128 input.rewind(); 17129 s = -1; 17130 if ( (synpred52_Java()) ) {s = 20;} 17131 17132 else if ( (synpred53_Java()) ) {s = 15;} 17133 17134 else if ( (synpred54_Java()) ) {s = 17;} 17135 17136 else if ( (true) ) {s = 19;} 17137 17138 17139 input.seek(index39_8); 17140 if ( s>=0 ) return s; 17141 break; 17142 case 8 : 17143 int LA39_9 = input.LA(1); 17144 17145 17146 int index39_9 = input.index(); 17147 input.rewind(); 17148 s = -1; 17149 if ( (synpred52_Java()) ) {s = 20;} 17150 17151 else if ( (synpred53_Java()) ) {s = 15;} 17152 17153 else if ( (synpred54_Java()) ) {s = 17;} 17154 17155 else if ( (true) ) {s = 19;} 17156 17157 17158 input.seek(index39_9); 17159 if ( s>=0 ) return s; 17160 break; 17161 case 9 : 17162 int LA39_10 = input.LA(1); 17163 17164 17165 int index39_10 = input.index(); 17166 input.rewind(); 17167 s = -1; 17168 if ( (synpred52_Java()) ) {s = 20;} 17169 17170 else if ( (synpred53_Java()) ) {s = 15;} 17171 17172 else if ( (synpred54_Java()) ) {s = 17;} 17173 17174 else if ( (true) ) {s = 19;} 17175 17176 17177 input.seek(index39_10); 17178 if ( s>=0 ) return s; 17179 break; 17180 case 10 : 17181 int LA39_11 = input.LA(1); 17182 17183 17184 int index39_11 = input.index(); 17185 input.rewind(); 17186 s = -1; 17187 if ( (synpred52_Java()) ) {s = 20;} 17188 17189 else if ( (synpred53_Java()) ) {s = 15;} 17190 17191 else if ( (synpred54_Java()) ) {s = 17;} 17192 17193 else if ( (true) ) {s = 19;} 17194 17195 17196 input.seek(index39_11); 17197 if ( s>=0 ) return s; 17198 break; 17199 case 11 : 17200 int LA39_12 = input.LA(1); 17201 17202 17203 int index39_12 = input.index(); 17204 input.rewind(); 17205 s = -1; 17206 if ( (synpred52_Java()) ) {s = 20;} 17207 17208 else if ( (synpred53_Java()) ) {s = 15;} 17209 17210 else if ( (synpred54_Java()) ) {s = 17;} 17211 17212 else if ( (true) ) {s = 19;} 17213 17214 17215 input.seek(index39_12); 17216 if ( s>=0 ) return s; 17217 break; 17218 case 12 : 17219 int LA39_13 = input.LA(1); 17220 17221 17222 int index39_13 = input.index(); 17223 input.rewind(); 17224 s = -1; 17225 if ( (synpred52_Java()) ) {s = 20;} 17226 17227 else if ( (synpred53_Java()) ) {s = 15;} 17228 17229 17230 input.seek(index39_13); 17231 if ( s>=0 ) return s; 17232 break; 17233 case 13 : 17234 int LA39_14 = input.LA(1); 17235 17236 17237 int index39_14 = input.index(); 17238 input.rewind(); 17239 s = -1; 17240 if ( (synpred52_Java()) ) {s = 20;} 17241 17242 else if ( (synpred53_Java()) ) {s = 15;} 17243 17244 17245 input.seek(index39_14); 17246 if ( s>=0 ) return s; 17247 break; 17248 } 17249 if (state.backtracking>0) {state.failed=true; return -1;} 17250 NoViableAltException nvae = 17251 new NoViableAltException(getDescription(), 39, _s, input); 17252 error(nvae); 17253 throw nvae; 17254 } 17255 } 17256 static final String DFA49_eotS = 17257 "\22\uffff"; 17258 static final String DFA49_eofS = 17259 "\22\uffff"; 17260 static final String DFA49_minS = 17261 "\1\4\16\0\3\uffff"; 17262 static final String DFA49_maxS = 17263 "\1\165\16\0\3\uffff"; 17264 static final String DFA49_acceptS = 17265 "\17\uffff\1\2\1\uffff\1\1"; 17266 static final String DFA49_specialS = 17267 "\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"+ 17268 "\1\15\3\uffff}>"; 17269 static final String[] DFA49_transitionS = { 17270 "\1\16\27\uffff\1\6\1\uffff\1\17\1\uffff\1\17\2\uffff\1\17\5"+ 17271 "\uffff\1\17\3\uffff\1\7\1\uffff\1\17\6\uffff\1\17\1\uffff\1"+ 17272 "\17\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\17\1\5\1\14\2\uffff\1"+ 17273 "\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1\2\uffff\1\15", 17274 "\1\uffff", 17275 "\1\uffff", 17276 "\1\uffff", 17277 "\1\uffff", 17278 "\1\uffff", 17279 "\1\uffff", 17280 "\1\uffff", 17281 "\1\uffff", 17282 "\1\uffff", 17283 "\1\uffff", 17284 "\1\uffff", 17285 "\1\uffff", 17286 "\1\uffff", 17287 "\1\uffff", 17288 "", 17289 "", 17290 "" 17291 }; 17292 17293 static final short[] DFA49_eot = DFA.unpackEncodedString(DFA49_eotS); 17294 static final short[] DFA49_eof = DFA.unpackEncodedString(DFA49_eofS); 17295 static final char[] DFA49_min = DFA.unpackEncodedStringToUnsignedChars(DFA49_minS); 17296 static final char[] DFA49_max = DFA.unpackEncodedStringToUnsignedChars(DFA49_maxS); 17297 static final short[] DFA49_accept = DFA.unpackEncodedString(DFA49_acceptS); 17298 static final short[] DFA49_special = DFA.unpackEncodedString(DFA49_specialS); 17299 static final short[][] DFA49_transition; 17300 17301 static { 17302 int numStates = DFA49_transitionS.length; 17303 DFA49_transition = new short[numStates][]; 17304 for (int i=0; i<numStates; i++) { 17305 DFA49_transition[i] = DFA.unpackEncodedString(DFA49_transitionS[i]); 17306 } 17307 } 17308 17309 class DFA49 extends DFA { 17310 DFA49(BaseRecognizer recognizer)17311 public DFA49(BaseRecognizer recognizer) { 17312 this.recognizer = recognizer; 17313 this.decisionNumber = 49; 17314 this.eot = DFA49_eot; 17315 this.eof = DFA49_eof; 17316 this.min = DFA49_min; 17317 this.max = DFA49_max; 17318 this.accept = DFA49_accept; 17319 this.special = DFA49_special; 17320 this.transition = DFA49_transition; 17321 } getDescription()17322 public String getDescription() { 17323 return "510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) );"; 17324 } error(NoViableAltException nvae)17325 public void error(NoViableAltException nvae) { 17326 dbg.recognitionException(nvae); 17327 } specialStateTransition(int s, IntStream _input)17328 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 17329 TokenStream input = (TokenStream)_input; 17330 int _s = s; 17331 switch ( s ) { 17332 case 0 : 17333 int LA49_1 = input.LA(1); 17334 17335 17336 int index49_1 = input.index(); 17337 input.rewind(); 17338 s = -1; 17339 if ( (synpred59_Java()) ) {s = 17;} 17340 17341 else if ( (true) ) {s = 15;} 17342 17343 17344 input.seek(index49_1); 17345 if ( s>=0 ) return s; 17346 break; 17347 case 1 : 17348 int LA49_2 = input.LA(1); 17349 17350 17351 int index49_2 = input.index(); 17352 input.rewind(); 17353 s = -1; 17354 if ( (synpred59_Java()) ) {s = 17;} 17355 17356 else if ( (true) ) {s = 15;} 17357 17358 17359 input.seek(index49_2); 17360 if ( s>=0 ) return s; 17361 break; 17362 case 2 : 17363 int LA49_3 = input.LA(1); 17364 17365 17366 int index49_3 = input.index(); 17367 input.rewind(); 17368 s = -1; 17369 if ( (synpred59_Java()) ) {s = 17;} 17370 17371 else if ( (true) ) {s = 15;} 17372 17373 17374 input.seek(index49_3); 17375 if ( s>=0 ) return s; 17376 break; 17377 case 3 : 17378 int LA49_4 = input.LA(1); 17379 17380 17381 int index49_4 = input.index(); 17382 input.rewind(); 17383 s = -1; 17384 if ( (synpred59_Java()) ) {s = 17;} 17385 17386 else if ( (true) ) {s = 15;} 17387 17388 17389 input.seek(index49_4); 17390 if ( s>=0 ) return s; 17391 break; 17392 case 4 : 17393 int LA49_5 = input.LA(1); 17394 17395 17396 int index49_5 = input.index(); 17397 input.rewind(); 17398 s = -1; 17399 if ( (synpred59_Java()) ) {s = 17;} 17400 17401 else if ( (true) ) {s = 15;} 17402 17403 17404 input.seek(index49_5); 17405 if ( s>=0 ) return s; 17406 break; 17407 case 5 : 17408 int LA49_6 = input.LA(1); 17409 17410 17411 int index49_6 = input.index(); 17412 input.rewind(); 17413 s = -1; 17414 if ( (synpred59_Java()) ) {s = 17;} 17415 17416 else if ( (true) ) {s = 15;} 17417 17418 17419 input.seek(index49_6); 17420 if ( s>=0 ) return s; 17421 break; 17422 case 6 : 17423 int LA49_7 = input.LA(1); 17424 17425 17426 int index49_7 = input.index(); 17427 input.rewind(); 17428 s = -1; 17429 if ( (synpred59_Java()) ) {s = 17;} 17430 17431 else if ( (true) ) {s = 15;} 17432 17433 17434 input.seek(index49_7); 17435 if ( s>=0 ) return s; 17436 break; 17437 case 7 : 17438 int LA49_8 = input.LA(1); 17439 17440 17441 int index49_8 = input.index(); 17442 input.rewind(); 17443 s = -1; 17444 if ( (synpred59_Java()) ) {s = 17;} 17445 17446 else if ( (true) ) {s = 15;} 17447 17448 17449 input.seek(index49_8); 17450 if ( s>=0 ) return s; 17451 break; 17452 case 8 : 17453 int LA49_9 = input.LA(1); 17454 17455 17456 int index49_9 = input.index(); 17457 input.rewind(); 17458 s = -1; 17459 if ( (synpred59_Java()) ) {s = 17;} 17460 17461 else if ( (true) ) {s = 15;} 17462 17463 17464 input.seek(index49_9); 17465 if ( s>=0 ) return s; 17466 break; 17467 case 9 : 17468 int LA49_10 = input.LA(1); 17469 17470 17471 int index49_10 = input.index(); 17472 input.rewind(); 17473 s = -1; 17474 if ( (synpred59_Java()) ) {s = 17;} 17475 17476 else if ( (true) ) {s = 15;} 17477 17478 17479 input.seek(index49_10); 17480 if ( s>=0 ) return s; 17481 break; 17482 case 10 : 17483 int LA49_11 = input.LA(1); 17484 17485 17486 int index49_11 = input.index(); 17487 input.rewind(); 17488 s = -1; 17489 if ( (synpred59_Java()) ) {s = 17;} 17490 17491 else if ( (true) ) {s = 15;} 17492 17493 17494 input.seek(index49_11); 17495 if ( s>=0 ) return s; 17496 break; 17497 case 11 : 17498 int LA49_12 = input.LA(1); 17499 17500 17501 int index49_12 = input.index(); 17502 input.rewind(); 17503 s = -1; 17504 if ( (synpred59_Java()) ) {s = 17;} 17505 17506 else if ( (true) ) {s = 15;} 17507 17508 17509 input.seek(index49_12); 17510 if ( s>=0 ) return s; 17511 break; 17512 case 12 : 17513 int LA49_13 = input.LA(1); 17514 17515 17516 int index49_13 = input.index(); 17517 input.rewind(); 17518 s = -1; 17519 if ( (synpred59_Java()) ) {s = 17;} 17520 17521 else if ( (true) ) {s = 15;} 17522 17523 17524 input.seek(index49_13); 17525 if ( s>=0 ) return s; 17526 break; 17527 case 13 : 17528 int LA49_14 = input.LA(1); 17529 17530 17531 int index49_14 = input.index(); 17532 input.rewind(); 17533 s = -1; 17534 if ( (synpred59_Java()) ) {s = 17;} 17535 17536 else if ( (true) ) {s = 15;} 17537 17538 17539 input.seek(index49_14); 17540 if ( s>=0 ) return s; 17541 break; 17542 } 17543 if (state.backtracking>0) {state.failed=true; return -1;} 17544 NoViableAltException nvae = 17545 new NoViableAltException(getDescription(), 49, _s, input); 17546 error(nvae); 17547 throw nvae; 17548 } 17549 } 17550 static final String DFA42_eotS = 17551 "\55\uffff"; 17552 static final String DFA42_eofS = 17553 "\55\uffff"; 17554 static final String DFA42_minS = 17555 "\1\4\1\uffff\10\0\43\uffff"; 17556 static final String DFA42_maxS = 17557 "\1\165\1\uffff\10\0\43\uffff"; 17558 static final String DFA42_acceptS = 17559 "\1\uffff\1\1\10\uffff\1\2\42\uffff"; 17560 static final String DFA42_specialS = 17561 "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>"; 17562 static final String[] DFA42_transitionS = { 17563 "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+ 17564 "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+ 17565 "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+ 17566 "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+ 17567 "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+ 17568 "\1\12\2\uffff\1\1", 17569 "", 17570 "\1\uffff", 17571 "\1\uffff", 17572 "\1\uffff", 17573 "\1\uffff", 17574 "\1\uffff", 17575 "\1\uffff", 17576 "\1\uffff", 17577 "\1\uffff", 17578 "", 17579 "", 17580 "", 17581 "", 17582 "", 17583 "", 17584 "", 17585 "", 17586 "", 17587 "", 17588 "", 17589 "", 17590 "", 17591 "", 17592 "", 17593 "", 17594 "", 17595 "", 17596 "", 17597 "", 17598 "", 17599 "", 17600 "", 17601 "", 17602 "", 17603 "", 17604 "", 17605 "", 17606 "", 17607 "", 17608 "", 17609 "", 17610 "", 17611 "", 17612 "" 17613 }; 17614 17615 static final short[] DFA42_eot = DFA.unpackEncodedString(DFA42_eotS); 17616 static final short[] DFA42_eof = DFA.unpackEncodedString(DFA42_eofS); 17617 static final char[] DFA42_min = DFA.unpackEncodedStringToUnsignedChars(DFA42_minS); 17618 static final char[] DFA42_max = DFA.unpackEncodedStringToUnsignedChars(DFA42_maxS); 17619 static final short[] DFA42_accept = DFA.unpackEncodedString(DFA42_acceptS); 17620 static final short[] DFA42_special = DFA.unpackEncodedString(DFA42_specialS); 17621 static final short[][] DFA42_transition; 17622 17623 static { 17624 int numStates = DFA42_transitionS.length; 17625 DFA42_transition = new short[numStates][]; 17626 for (int i=0; i<numStates; i++) { 17627 DFA42_transition[i] = DFA.unpackEncodedString(DFA42_transitionS[i]); 17628 } 17629 } 17630 17631 class DFA42 extends DFA { 17632 DFA42(BaseRecognizer recognizer)17633 public DFA42(BaseRecognizer recognizer) { 17634 this.recognizer = recognizer; 17635 this.decisionNumber = 42; 17636 this.eot = DFA42_eot; 17637 this.eof = DFA42_eof; 17638 this.min = DFA42_min; 17639 this.max = DFA42_max; 17640 this.accept = DFA42_accept; 17641 this.special = DFA42_special; 17642 this.transition = DFA42_transition; 17643 } getDescription()17644 public String getDescription() { 17645 return "521:9: ( explicitConstructorInvocation )?"; 17646 } error(NoViableAltException nvae)17647 public void error(NoViableAltException nvae) { 17648 dbg.recognitionException(nvae); 17649 } specialStateTransition(int s, IntStream _input)17650 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 17651 TokenStream input = (TokenStream)_input; 17652 int _s = s; 17653 switch ( s ) { 17654 case 0 : 17655 int LA42_2 = input.LA(1); 17656 17657 17658 int index42_2 = input.index(); 17659 input.rewind(); 17660 s = -1; 17661 if ( (synpred57_Java()) ) {s = 1;} 17662 17663 else if ( (true) ) {s = 10;} 17664 17665 17666 input.seek(index42_2); 17667 if ( s>=0 ) return s; 17668 break; 17669 case 1 : 17670 int LA42_3 = input.LA(1); 17671 17672 17673 int index42_3 = input.index(); 17674 input.rewind(); 17675 s = -1; 17676 if ( (synpred57_Java()) ) {s = 1;} 17677 17678 else if ( (true) ) {s = 10;} 17679 17680 17681 input.seek(index42_3); 17682 if ( s>=0 ) return s; 17683 break; 17684 case 2 : 17685 int LA42_4 = input.LA(1); 17686 17687 17688 int index42_4 = input.index(); 17689 input.rewind(); 17690 s = -1; 17691 if ( (synpred57_Java()) ) {s = 1;} 17692 17693 else if ( (true) ) {s = 10;} 17694 17695 17696 input.seek(index42_4); 17697 if ( s>=0 ) return s; 17698 break; 17699 case 3 : 17700 int LA42_5 = input.LA(1); 17701 17702 17703 int index42_5 = input.index(); 17704 input.rewind(); 17705 s = -1; 17706 if ( (synpred57_Java()) ) {s = 1;} 17707 17708 else if ( (true) ) {s = 10;} 17709 17710 17711 input.seek(index42_5); 17712 if ( s>=0 ) return s; 17713 break; 17714 case 4 : 17715 int LA42_6 = input.LA(1); 17716 17717 17718 int index42_6 = input.index(); 17719 input.rewind(); 17720 s = -1; 17721 if ( (synpred57_Java()) ) {s = 1;} 17722 17723 else if ( (true) ) {s = 10;} 17724 17725 17726 input.seek(index42_6); 17727 if ( s>=0 ) return s; 17728 break; 17729 case 5 : 17730 int LA42_7 = input.LA(1); 17731 17732 17733 int index42_7 = input.index(); 17734 input.rewind(); 17735 s = -1; 17736 if ( (synpred57_Java()) ) {s = 1;} 17737 17738 else if ( (true) ) {s = 10;} 17739 17740 17741 input.seek(index42_7); 17742 if ( s>=0 ) return s; 17743 break; 17744 case 6 : 17745 int LA42_8 = input.LA(1); 17746 17747 17748 int index42_8 = input.index(); 17749 input.rewind(); 17750 s = -1; 17751 if ( (synpred57_Java()) ) {s = 1;} 17752 17753 else if ( (true) ) {s = 10;} 17754 17755 17756 input.seek(index42_8); 17757 if ( s>=0 ) return s; 17758 break; 17759 case 7 : 17760 int LA42_9 = input.LA(1); 17761 17762 17763 int index42_9 = input.index(); 17764 input.rewind(); 17765 s = -1; 17766 if ( (synpred57_Java()) ) {s = 1;} 17767 17768 else if ( (true) ) {s = 10;} 17769 17770 17771 input.seek(index42_9); 17772 if ( s>=0 ) return s; 17773 break; 17774 } 17775 if (state.backtracking>0) {state.failed=true; return -1;} 17776 NoViableAltException nvae = 17777 new NoViableAltException(getDescription(), 42, _s, input); 17778 error(nvae); 17779 throw nvae; 17780 } 17781 } 17782 static final String DFA53_eotS = 17783 "\26\uffff"; 17784 static final String DFA53_eofS = 17785 "\26\uffff"; 17786 static final String DFA53_minS = 17787 "\1\4\16\0\7\uffff"; 17788 static final String DFA53_maxS = 17789 "\1\165\16\0\7\uffff"; 17790 static final String DFA53_acceptS = 17791 "\17\uffff\1\2\1\uffff\1\3\1\4\1\uffff\1\5\1\1"; 17792 static final String DFA53_specialS = 17793 "\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"+ 17794 "\1\15\7\uffff}>"; 17795 static final String[] DFA53_transitionS = { 17796 "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+ 17797 "\22\4\uffff\1\16\1\uffff\1\22\1\uffff\1\7\1\uffff\1\16\6\uffff"+ 17798 "\1\16\1\21\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+ 17799 "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\7\uffff\1\24"+ 17800 "\35\uffff\1\1\2\uffff\1\17", 17801 "\1\uffff", 17802 "\1\uffff", 17803 "\1\uffff", 17804 "\1\uffff", 17805 "\1\uffff", 17806 "\1\uffff", 17807 "\1\uffff", 17808 "\1\uffff", 17809 "\1\uffff", 17810 "\1\uffff", 17811 "\1\uffff", 17812 "\1\uffff", 17813 "\1\uffff", 17814 "\1\uffff", 17815 "", 17816 "", 17817 "", 17818 "", 17819 "", 17820 "", 17821 "" 17822 }; 17823 17824 static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS); 17825 static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS); 17826 static final char[] DFA53_min = DFA.unpackEncodedStringToUnsignedChars(DFA53_minS); 17827 static final char[] DFA53_max = DFA.unpackEncodedStringToUnsignedChars(DFA53_maxS); 17828 static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS); 17829 static final short[] DFA53_special = DFA.unpackEncodedString(DFA53_specialS); 17830 static final short[][] DFA53_transition; 17831 17832 static { 17833 int numStates = DFA53_transitionS.length; 17834 DFA53_transition = new short[numStates][]; 17835 for (int i=0; i<numStates; i++) { 17836 DFA53_transition[i] = DFA.unpackEncodedString(DFA53_transitionS[i]); 17837 } 17838 } 17839 17840 class DFA53 extends DFA { 17841 DFA53(BaseRecognizer recognizer)17842 public DFA53(BaseRecognizer recognizer) { 17843 this.recognizer = recognizer; 17844 this.decisionNumber = 53; 17845 this.eot = DFA53_eot; 17846 this.eof = DFA53_eof; 17847 this.min = DFA53_min; 17848 this.max = DFA53_max; 17849 this.accept = DFA53_accept; 17850 this.special = DFA53_special; 17851 this.transition = DFA53_transition; 17852 } getDescription()17853 public String getDescription() { 17854 return "562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );"; 17855 } error(NoViableAltException nvae)17856 public void error(NoViableAltException nvae) { 17857 dbg.recognitionException(nvae); 17858 } specialStateTransition(int s, IntStream _input)17859 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 17860 TokenStream input = (TokenStream)_input; 17861 int _s = s; 17862 switch ( s ) { 17863 case 0 : 17864 int LA53_1 = input.LA(1); 17865 17866 17867 int index53_1 = input.index(); 17868 input.rewind(); 17869 s = -1; 17870 if ( (synpred68_Java()) ) {s = 21;} 17871 17872 else if ( (synpred69_Java()) ) {s = 15;} 17873 17874 else if ( (synpred70_Java()) ) {s = 17;} 17875 17876 else if ( (synpred71_Java()) ) {s = 18;} 17877 17878 17879 input.seek(index53_1); 17880 if ( s>=0 ) return s; 17881 break; 17882 case 1 : 17883 int LA53_2 = input.LA(1); 17884 17885 17886 int index53_2 = input.index(); 17887 input.rewind(); 17888 s = -1; 17889 if ( (synpred68_Java()) ) {s = 21;} 17890 17891 else if ( (synpred69_Java()) ) {s = 15;} 17892 17893 else if ( (synpred70_Java()) ) {s = 17;} 17894 17895 else if ( (synpred71_Java()) ) {s = 18;} 17896 17897 17898 input.seek(index53_2); 17899 if ( s>=0 ) return s; 17900 break; 17901 case 2 : 17902 int LA53_3 = input.LA(1); 17903 17904 17905 int index53_3 = input.index(); 17906 input.rewind(); 17907 s = -1; 17908 if ( (synpred68_Java()) ) {s = 21;} 17909 17910 else if ( (synpred69_Java()) ) {s = 15;} 17911 17912 else if ( (synpred70_Java()) ) {s = 17;} 17913 17914 else if ( (synpred71_Java()) ) {s = 18;} 17915 17916 17917 input.seek(index53_3); 17918 if ( s>=0 ) return s; 17919 break; 17920 case 3 : 17921 int LA53_4 = input.LA(1); 17922 17923 17924 int index53_4 = input.index(); 17925 input.rewind(); 17926 s = -1; 17927 if ( (synpred68_Java()) ) {s = 21;} 17928 17929 else if ( (synpred69_Java()) ) {s = 15;} 17930 17931 else if ( (synpred70_Java()) ) {s = 17;} 17932 17933 else if ( (synpred71_Java()) ) {s = 18;} 17934 17935 17936 input.seek(index53_4); 17937 if ( s>=0 ) return s; 17938 break; 17939 case 4 : 17940 int LA53_5 = input.LA(1); 17941 17942 17943 int index53_5 = input.index(); 17944 input.rewind(); 17945 s = -1; 17946 if ( (synpred68_Java()) ) {s = 21;} 17947 17948 else if ( (synpred69_Java()) ) {s = 15;} 17949 17950 else if ( (synpred70_Java()) ) {s = 17;} 17951 17952 else if ( (synpred71_Java()) ) {s = 18;} 17953 17954 17955 input.seek(index53_5); 17956 if ( s>=0 ) return s; 17957 break; 17958 case 5 : 17959 int LA53_6 = input.LA(1); 17960 17961 17962 int index53_6 = input.index(); 17963 input.rewind(); 17964 s = -1; 17965 if ( (synpred68_Java()) ) {s = 21;} 17966 17967 else if ( (synpred69_Java()) ) {s = 15;} 17968 17969 else if ( (synpred70_Java()) ) {s = 17;} 17970 17971 else if ( (synpred71_Java()) ) {s = 18;} 17972 17973 17974 input.seek(index53_6); 17975 if ( s>=0 ) return s; 17976 break; 17977 case 6 : 17978 int LA53_7 = input.LA(1); 17979 17980 17981 int index53_7 = input.index(); 17982 input.rewind(); 17983 s = -1; 17984 if ( (synpred68_Java()) ) {s = 21;} 17985 17986 else if ( (synpred69_Java()) ) {s = 15;} 17987 17988 else if ( (synpred70_Java()) ) {s = 17;} 17989 17990 else if ( (synpred71_Java()) ) {s = 18;} 17991 17992 17993 input.seek(index53_7); 17994 if ( s>=0 ) return s; 17995 break; 17996 case 7 : 17997 int LA53_8 = input.LA(1); 17998 17999 18000 int index53_8 = input.index(); 18001 input.rewind(); 18002 s = -1; 18003 if ( (synpred68_Java()) ) {s = 21;} 18004 18005 else if ( (synpred69_Java()) ) {s = 15;} 18006 18007 else if ( (synpred70_Java()) ) {s = 17;} 18008 18009 else if ( (synpred71_Java()) ) {s = 18;} 18010 18011 18012 input.seek(index53_8); 18013 if ( s>=0 ) return s; 18014 break; 18015 case 8 : 18016 int LA53_9 = input.LA(1); 18017 18018 18019 int index53_9 = input.index(); 18020 input.rewind(); 18021 s = -1; 18022 if ( (synpred68_Java()) ) {s = 21;} 18023 18024 else if ( (synpred69_Java()) ) {s = 15;} 18025 18026 else if ( (synpred70_Java()) ) {s = 17;} 18027 18028 else if ( (synpred71_Java()) ) {s = 18;} 18029 18030 18031 input.seek(index53_9); 18032 if ( s>=0 ) return s; 18033 break; 18034 case 9 : 18035 int LA53_10 = input.LA(1); 18036 18037 18038 int index53_10 = input.index(); 18039 input.rewind(); 18040 s = -1; 18041 if ( (synpred68_Java()) ) {s = 21;} 18042 18043 else if ( (synpred69_Java()) ) {s = 15;} 18044 18045 else if ( (synpred70_Java()) ) {s = 17;} 18046 18047 else if ( (synpred71_Java()) ) {s = 18;} 18048 18049 18050 input.seek(index53_10); 18051 if ( s>=0 ) return s; 18052 break; 18053 case 10 : 18054 int LA53_11 = input.LA(1); 18055 18056 18057 int index53_11 = input.index(); 18058 input.rewind(); 18059 s = -1; 18060 if ( (synpred68_Java()) ) {s = 21;} 18061 18062 else if ( (synpred69_Java()) ) {s = 15;} 18063 18064 else if ( (synpred70_Java()) ) {s = 17;} 18065 18066 else if ( (synpred71_Java()) ) {s = 18;} 18067 18068 18069 input.seek(index53_11); 18070 if ( s>=0 ) return s; 18071 break; 18072 case 11 : 18073 int LA53_12 = input.LA(1); 18074 18075 18076 int index53_12 = input.index(); 18077 input.rewind(); 18078 s = -1; 18079 if ( (synpred68_Java()) ) {s = 21;} 18080 18081 else if ( (synpred69_Java()) ) {s = 15;} 18082 18083 else if ( (synpred70_Java()) ) {s = 17;} 18084 18085 else if ( (synpred71_Java()) ) {s = 18;} 18086 18087 18088 input.seek(index53_12); 18089 if ( s>=0 ) return s; 18090 break; 18091 case 12 : 18092 int LA53_13 = input.LA(1); 18093 18094 18095 int index53_13 = input.index(); 18096 input.rewind(); 18097 s = -1; 18098 if ( (synpred68_Java()) ) {s = 21;} 18099 18100 else if ( (synpred69_Java()) ) {s = 15;} 18101 18102 18103 input.seek(index53_13); 18104 if ( s>=0 ) return s; 18105 break; 18106 case 13 : 18107 int LA53_14 = input.LA(1); 18108 18109 18110 int index53_14 = input.index(); 18111 input.rewind(); 18112 s = -1; 18113 if ( (synpred68_Java()) ) {s = 21;} 18114 18115 else if ( (synpred69_Java()) ) {s = 15;} 18116 18117 18118 input.seek(index53_14); 18119 if ( s>=0 ) return s; 18120 break; 18121 } 18122 if (state.backtracking>0) {state.failed=true; return -1;} 18123 NoViableAltException nvae = 18124 new NoViableAltException(getDescription(), 53, _s, input); 18125 error(nvae); 18126 throw nvae; 18127 } 18128 } 18129 static final String DFA76_eotS = 18130 "\12\uffff"; 18131 static final String DFA76_eofS = 18132 "\12\uffff"; 18133 static final String DFA76_minS = 18134 "\1\4\1\uffff\1\0\1\uffff\1\0\5\uffff"; 18135 static final String DFA76_maxS = 18136 "\1\165\1\uffff\1\0\1\uffff\1\0\5\uffff"; 18137 static final String DFA76_acceptS = 18138 "\1\uffff\1\1\1\uffff\1\2\6\uffff"; 18139 static final String DFA76_specialS = 18140 "\2\uffff\1\0\1\uffff\1\1\5\uffff}>"; 18141 static final String[] DFA76_transitionS = { 18142 "\12\3\20\uffff\1\3\1\uffff\1\3\2\uffff\1\3\5\uffff\1\3\5\uffff"+ 18143 "\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\5\uffff\1\3\2\uffff"+ 18144 "\1\4\2\uffff\1\2\4\uffff\1\3\2\uffff\1\3\46\uffff\1\1", 18145 "", 18146 "\1\uffff", 18147 "", 18148 "\1\uffff", 18149 "", 18150 "", 18151 "", 18152 "", 18153 "" 18154 }; 18155 18156 static final short[] DFA76_eot = DFA.unpackEncodedString(DFA76_eotS); 18157 static final short[] DFA76_eof = DFA.unpackEncodedString(DFA76_eofS); 18158 static final char[] DFA76_min = DFA.unpackEncodedStringToUnsignedChars(DFA76_minS); 18159 static final char[] DFA76_max = DFA.unpackEncodedStringToUnsignedChars(DFA76_maxS); 18160 static final short[] DFA76_accept = DFA.unpackEncodedString(DFA76_acceptS); 18161 static final short[] DFA76_special = DFA.unpackEncodedString(DFA76_specialS); 18162 static final short[][] DFA76_transition; 18163 18164 static { 18165 int numStates = DFA76_transitionS.length; 18166 DFA76_transition = new short[numStates][]; 18167 for (int i=0; i<numStates; i++) { 18168 DFA76_transition[i] = DFA.unpackEncodedString(DFA76_transitionS[i]); 18169 } 18170 } 18171 18172 class DFA76 extends DFA { 18173 DFA76(BaseRecognizer recognizer)18174 public DFA76(BaseRecognizer recognizer) { 18175 this.recognizer = recognizer; 18176 this.decisionNumber = 76; 18177 this.eot = DFA76_eot; 18178 this.eof = DFA76_eof; 18179 this.min = DFA76_min; 18180 this.max = DFA76_max; 18181 this.accept = DFA76_accept; 18182 this.special = DFA76_special; 18183 this.transition = DFA76_transition; 18184 } getDescription()18185 public String getDescription() { 18186 return "688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );"; 18187 } error(NoViableAltException nvae)18188 public void error(NoViableAltException nvae) { 18189 dbg.recognitionException(nvae); 18190 } specialStateTransition(int s, IntStream _input)18191 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 18192 TokenStream input = (TokenStream)_input; 18193 int _s = s; 18194 switch ( s ) { 18195 case 0 : 18196 int LA76_2 = input.LA(1); 18197 18198 18199 int index76_2 = input.index(); 18200 input.rewind(); 18201 s = -1; 18202 if ( (synpred103_Java()) ) {s = 1;} 18203 18204 else if ( (true) ) {s = 3;} 18205 18206 18207 input.seek(index76_2); 18208 if ( s>=0 ) return s; 18209 break; 18210 case 1 : 18211 int LA76_4 = input.LA(1); 18212 18213 18214 int index76_4 = input.index(); 18215 input.rewind(); 18216 s = -1; 18217 if ( (synpred103_Java()) ) {s = 1;} 18218 18219 else if ( (true) ) {s = 3;} 18220 18221 18222 input.seek(index76_4); 18223 if ( s>=0 ) return s; 18224 break; 18225 } 18226 if (state.backtracking>0) {state.failed=true; return -1;} 18227 NoViableAltException nvae = 18228 new NoViableAltException(getDescription(), 76, _s, input); 18229 error(nvae); 18230 throw nvae; 18231 } 18232 } 18233 static final String DFA87_eotS = 18234 "\26\uffff"; 18235 static final String DFA87_eofS = 18236 "\26\uffff"; 18237 static final String DFA87_minS = 18238 "\1\4\16\0\7\uffff"; 18239 static final String DFA87_maxS = 18240 "\1\162\16\0\7\uffff"; 18241 static final String DFA87_acceptS = 18242 "\17\uffff\1\3\1\4\1\5\1\7\1\1\1\2\1\6"; 18243 static final String DFA87_specialS = 18244 "\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"+ 18245 "\1\15\7\uffff}>"; 18246 static final String[] DFA87_transitionS = { 18247 "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+ 18248 "\17\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+ 18249 "\1\16\1\20\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+ 18250 "\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13\7\uffff\1\22\35\uffff"+ 18251 "\1\1", 18252 "\1\uffff", 18253 "\1\uffff", 18254 "\1\uffff", 18255 "\1\uffff", 18256 "\1\uffff", 18257 "\1\uffff", 18258 "\1\uffff", 18259 "\1\uffff", 18260 "\1\uffff", 18261 "\1\uffff", 18262 "\1\uffff", 18263 "\1\uffff", 18264 "\1\uffff", 18265 "\1\uffff", 18266 "", 18267 "", 18268 "", 18269 "", 18270 "", 18271 "", 18272 "" 18273 }; 18274 18275 static final short[] DFA87_eot = DFA.unpackEncodedString(DFA87_eotS); 18276 static final short[] DFA87_eof = DFA.unpackEncodedString(DFA87_eofS); 18277 static final char[] DFA87_min = DFA.unpackEncodedStringToUnsignedChars(DFA87_minS); 18278 static final char[] DFA87_max = DFA.unpackEncodedStringToUnsignedChars(DFA87_maxS); 18279 static final short[] DFA87_accept = DFA.unpackEncodedString(DFA87_acceptS); 18280 static final short[] DFA87_special = DFA.unpackEncodedString(DFA87_specialS); 18281 static final short[][] DFA87_transition; 18282 18283 static { 18284 int numStates = DFA87_transitionS.length; 18285 DFA87_transition = new short[numStates][]; 18286 for (int i=0; i<numStates; i++) { 18287 DFA87_transition[i] = DFA.unpackEncodedString(DFA87_transitionS[i]); 18288 } 18289 } 18290 18291 class DFA87 extends DFA { 18292 DFA87(BaseRecognizer recognizer)18293 public DFA87(BaseRecognizer recognizer) { 18294 this.recognizer = recognizer; 18295 this.decisionNumber = 87; 18296 this.eot = DFA87_eot; 18297 this.eof = DFA87_eof; 18298 this.min = DFA87_min; 18299 this.max = DFA87_max; 18300 this.accept = DFA87_accept; 18301 this.special = DFA87_special; 18302 this.transition = DFA87_transition; 18303 } getDescription()18304 public String getDescription() { 18305 return "772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );"; 18306 } error(NoViableAltException nvae)18307 public void error(NoViableAltException nvae) { 18308 dbg.recognitionException(nvae); 18309 } specialStateTransition(int s, IntStream _input)18310 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 18311 TokenStream input = (TokenStream)_input; 18312 int _s = s; 18313 switch ( s ) { 18314 case 0 : 18315 int LA87_1 = input.LA(1); 18316 18317 18318 int index87_1 = input.index(); 18319 input.rewind(); 18320 s = -1; 18321 if ( (synpred117_Java()) ) {s = 19;} 18322 18323 else if ( (synpred118_Java()) ) {s = 20;} 18324 18325 else if ( (synpred119_Java()) ) {s = 15;} 18326 18327 else if ( (synpred120_Java()) ) {s = 16;} 18328 18329 else if ( (synpred121_Java()) ) {s = 17;} 18330 18331 else if ( (synpred122_Java()) ) {s = 21;} 18332 18333 18334 input.seek(index87_1); 18335 if ( s>=0 ) return s; 18336 break; 18337 case 1 : 18338 int LA87_2 = input.LA(1); 18339 18340 18341 int index87_2 = input.index(); 18342 input.rewind(); 18343 s = -1; 18344 if ( (synpred117_Java()) ) {s = 19;} 18345 18346 else if ( (synpred118_Java()) ) {s = 20;} 18347 18348 else if ( (synpred119_Java()) ) {s = 15;} 18349 18350 else if ( (synpred120_Java()) ) {s = 16;} 18351 18352 else if ( (synpred121_Java()) ) {s = 17;} 18353 18354 else if ( (synpred122_Java()) ) {s = 21;} 18355 18356 18357 input.seek(index87_2); 18358 if ( s>=0 ) return s; 18359 break; 18360 case 2 : 18361 int LA87_3 = input.LA(1); 18362 18363 18364 int index87_3 = input.index(); 18365 input.rewind(); 18366 s = -1; 18367 if ( (synpred117_Java()) ) {s = 19;} 18368 18369 else if ( (synpred118_Java()) ) {s = 20;} 18370 18371 else if ( (synpred119_Java()) ) {s = 15;} 18372 18373 else if ( (synpred120_Java()) ) {s = 16;} 18374 18375 else if ( (synpred121_Java()) ) {s = 17;} 18376 18377 else if ( (synpred122_Java()) ) {s = 21;} 18378 18379 18380 input.seek(index87_3); 18381 if ( s>=0 ) return s; 18382 break; 18383 case 3 : 18384 int LA87_4 = input.LA(1); 18385 18386 18387 int index87_4 = input.index(); 18388 input.rewind(); 18389 s = -1; 18390 if ( (synpred117_Java()) ) {s = 19;} 18391 18392 else if ( (synpred118_Java()) ) {s = 20;} 18393 18394 else if ( (synpred119_Java()) ) {s = 15;} 18395 18396 else if ( (synpred120_Java()) ) {s = 16;} 18397 18398 else if ( (synpred121_Java()) ) {s = 17;} 18399 18400 else if ( (synpred122_Java()) ) {s = 21;} 18401 18402 18403 input.seek(index87_4); 18404 if ( s>=0 ) return s; 18405 break; 18406 case 4 : 18407 int LA87_5 = input.LA(1); 18408 18409 18410 int index87_5 = input.index(); 18411 input.rewind(); 18412 s = -1; 18413 if ( (synpred117_Java()) ) {s = 19;} 18414 18415 else if ( (synpred118_Java()) ) {s = 20;} 18416 18417 else if ( (synpred119_Java()) ) {s = 15;} 18418 18419 else if ( (synpred120_Java()) ) {s = 16;} 18420 18421 else if ( (synpred121_Java()) ) {s = 17;} 18422 18423 else if ( (synpred122_Java()) ) {s = 21;} 18424 18425 18426 input.seek(index87_5); 18427 if ( s>=0 ) return s; 18428 break; 18429 case 5 : 18430 int LA87_6 = input.LA(1); 18431 18432 18433 int index87_6 = input.index(); 18434 input.rewind(); 18435 s = -1; 18436 if ( (synpred117_Java()) ) {s = 19;} 18437 18438 else if ( (synpred118_Java()) ) {s = 20;} 18439 18440 else if ( (synpred119_Java()) ) {s = 15;} 18441 18442 else if ( (synpred120_Java()) ) {s = 16;} 18443 18444 else if ( (synpred121_Java()) ) {s = 17;} 18445 18446 else if ( (synpred122_Java()) ) {s = 21;} 18447 18448 18449 input.seek(index87_6); 18450 if ( s>=0 ) return s; 18451 break; 18452 case 6 : 18453 int LA87_7 = input.LA(1); 18454 18455 18456 int index87_7 = input.index(); 18457 input.rewind(); 18458 s = -1; 18459 if ( (synpred117_Java()) ) {s = 19;} 18460 18461 else if ( (synpred118_Java()) ) {s = 20;} 18462 18463 else if ( (synpred119_Java()) ) {s = 15;} 18464 18465 else if ( (synpred120_Java()) ) {s = 16;} 18466 18467 else if ( (synpred121_Java()) ) {s = 17;} 18468 18469 else if ( (synpred122_Java()) ) {s = 21;} 18470 18471 18472 input.seek(index87_7); 18473 if ( s>=0 ) return s; 18474 break; 18475 case 7 : 18476 int LA87_8 = input.LA(1); 18477 18478 18479 int index87_8 = input.index(); 18480 input.rewind(); 18481 s = -1; 18482 if ( (synpred117_Java()) ) {s = 19;} 18483 18484 else if ( (synpred118_Java()) ) {s = 20;} 18485 18486 else if ( (synpred119_Java()) ) {s = 15;} 18487 18488 else if ( (synpred120_Java()) ) {s = 16;} 18489 18490 else if ( (synpred121_Java()) ) {s = 17;} 18491 18492 else if ( (synpred122_Java()) ) {s = 21;} 18493 18494 18495 input.seek(index87_8); 18496 if ( s>=0 ) return s; 18497 break; 18498 case 8 : 18499 int LA87_9 = input.LA(1); 18500 18501 18502 int index87_9 = input.index(); 18503 input.rewind(); 18504 s = -1; 18505 if ( (synpred117_Java()) ) {s = 19;} 18506 18507 else if ( (synpred118_Java()) ) {s = 20;} 18508 18509 else if ( (synpred119_Java()) ) {s = 15;} 18510 18511 else if ( (synpred120_Java()) ) {s = 16;} 18512 18513 else if ( (synpred121_Java()) ) {s = 17;} 18514 18515 else if ( (synpred122_Java()) ) {s = 21;} 18516 18517 18518 input.seek(index87_9); 18519 if ( s>=0 ) return s; 18520 break; 18521 case 9 : 18522 int LA87_10 = input.LA(1); 18523 18524 18525 int index87_10 = input.index(); 18526 input.rewind(); 18527 s = -1; 18528 if ( (synpred117_Java()) ) {s = 19;} 18529 18530 else if ( (synpred118_Java()) ) {s = 20;} 18531 18532 else if ( (synpred119_Java()) ) {s = 15;} 18533 18534 else if ( (synpred120_Java()) ) {s = 16;} 18535 18536 else if ( (synpred121_Java()) ) {s = 17;} 18537 18538 else if ( (synpred122_Java()) ) {s = 21;} 18539 18540 18541 input.seek(index87_10); 18542 if ( s>=0 ) return s; 18543 break; 18544 case 10 : 18545 int LA87_11 = input.LA(1); 18546 18547 18548 int index87_11 = input.index(); 18549 input.rewind(); 18550 s = -1; 18551 if ( (synpred117_Java()) ) {s = 19;} 18552 18553 else if ( (synpred118_Java()) ) {s = 20;} 18554 18555 else if ( (synpred119_Java()) ) {s = 15;} 18556 18557 else if ( (synpred120_Java()) ) {s = 16;} 18558 18559 else if ( (synpred121_Java()) ) {s = 17;} 18560 18561 else if ( (synpred122_Java()) ) {s = 21;} 18562 18563 18564 input.seek(index87_11); 18565 if ( s>=0 ) return s; 18566 break; 18567 case 11 : 18568 int LA87_12 = input.LA(1); 18569 18570 18571 int index87_12 = input.index(); 18572 input.rewind(); 18573 s = -1; 18574 if ( (synpred117_Java()) ) {s = 19;} 18575 18576 else if ( (synpred118_Java()) ) {s = 20;} 18577 18578 else if ( (synpred119_Java()) ) {s = 15;} 18579 18580 else if ( (synpred120_Java()) ) {s = 16;} 18581 18582 else if ( (synpred121_Java()) ) {s = 17;} 18583 18584 else if ( (synpred122_Java()) ) {s = 21;} 18585 18586 18587 input.seek(index87_12); 18588 if ( s>=0 ) return s; 18589 break; 18590 case 12 : 18591 int LA87_13 = input.LA(1); 18592 18593 18594 int index87_13 = input.index(); 18595 input.rewind(); 18596 s = -1; 18597 if ( (synpred117_Java()) ) {s = 19;} 18598 18599 else if ( (synpred118_Java()) ) {s = 20;} 18600 18601 18602 input.seek(index87_13); 18603 if ( s>=0 ) return s; 18604 break; 18605 case 13 : 18606 int LA87_14 = input.LA(1); 18607 18608 18609 int index87_14 = input.index(); 18610 input.rewind(); 18611 s = -1; 18612 if ( (synpred117_Java()) ) {s = 19;} 18613 18614 else if ( (synpred118_Java()) ) {s = 20;} 18615 18616 18617 input.seek(index87_14); 18618 if ( s>=0 ) return s; 18619 break; 18620 } 18621 if (state.backtracking>0) {state.failed=true; return -1;} 18622 NoViableAltException nvae = 18623 new NoViableAltException(getDescription(), 87, _s, input); 18624 error(nvae); 18625 throw nvae; 18626 } 18627 } 18628 static final String DFA90_eotS = 18629 "\54\uffff"; 18630 static final String DFA90_eofS = 18631 "\54\uffff"; 18632 static final String DFA90_minS = 18633 "\1\4\4\0\6\uffff\1\0\40\uffff"; 18634 static final String DFA90_maxS = 18635 "\1\162\4\0\6\uffff\1\0\40\uffff"; 18636 static final String DFA90_acceptS = 18637 "\5\uffff\1\2\14\uffff\1\3\30\uffff\1\1"; 18638 static final String DFA90_specialS = 18639 "\1\uffff\1\0\1\1\1\2\1\3\6\uffff\1\4\40\uffff}>"; 18640 static final String[] DFA90_transitionS = { 18641 "\1\3\11\22\16\uffff\1\5\1\22\1\4\1\22\1\4\2\uffff\1\4\1\5\1"+ 18642 "\uffff\1\22\1\uffff\1\22\1\4\1\uffff\1\5\1\uffff\1\1\1\uffff"+ 18643 "\1\4\1\22\1\uffff\1\22\3\uffff\1\4\1\5\1\4\1\5\1\22\1\uffff"+ 18644 "\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"+ 18645 "\uffff\1\22\3\uffff\1\22\4\uffff\2\22\5\uffff\4\22\16\uffff"+ 18646 "\1\2", 18647 "\1\uffff", 18648 "\1\uffff", 18649 "\1\uffff", 18650 "\1\uffff", 18651 "", 18652 "", 18653 "", 18654 "", 18655 "", 18656 "", 18657 "\1\uffff", 18658 "", 18659 "", 18660 "", 18661 "", 18662 "", 18663 "", 18664 "", 18665 "", 18666 "", 18667 "", 18668 "", 18669 "", 18670 "", 18671 "", 18672 "", 18673 "", 18674 "", 18675 "", 18676 "", 18677 "", 18678 "", 18679 "", 18680 "", 18681 "", 18682 "", 18683 "", 18684 "", 18685 "", 18686 "", 18687 "", 18688 "", 18689 "" 18690 }; 18691 18692 static final short[] DFA90_eot = DFA.unpackEncodedString(DFA90_eotS); 18693 static final short[] DFA90_eof = DFA.unpackEncodedString(DFA90_eofS); 18694 static final char[] DFA90_min = DFA.unpackEncodedStringToUnsignedChars(DFA90_minS); 18695 static final char[] DFA90_max = DFA.unpackEncodedStringToUnsignedChars(DFA90_maxS); 18696 static final short[] DFA90_accept = DFA.unpackEncodedString(DFA90_acceptS); 18697 static final short[] DFA90_special = DFA.unpackEncodedString(DFA90_specialS); 18698 static final short[][] DFA90_transition; 18699 18700 static { 18701 int numStates = DFA90_transitionS.length; 18702 DFA90_transition = new short[numStates][]; 18703 for (int i=0; i<numStates; i++) { 18704 DFA90_transition[i] = DFA.unpackEncodedString(DFA90_transitionS[i]); 18705 } 18706 } 18707 18708 class DFA90 extends DFA { 18709 DFA90(BaseRecognizer recognizer)18710 public DFA90(BaseRecognizer recognizer) { 18711 this.recognizer = recognizer; 18712 this.decisionNumber = 90; 18713 this.eot = DFA90_eot; 18714 this.eof = DFA90_eof; 18715 this.min = DFA90_min; 18716 this.max = DFA90_max; 18717 this.accept = DFA90_accept; 18718 this.special = DFA90_special; 18719 this.transition = DFA90_transition; 18720 } getDescription()18721 public String getDescription() { 18722 return "823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );"; 18723 } error(NoViableAltException nvae)18724 public void error(NoViableAltException nvae) { 18725 dbg.recognitionException(nvae); 18726 } specialStateTransition(int s, IntStream _input)18727 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 18728 TokenStream input = (TokenStream)_input; 18729 int _s = s; 18730 switch ( s ) { 18731 case 0 : 18732 int LA90_1 = input.LA(1); 18733 18734 18735 int index90_1 = input.index(); 18736 input.rewind(); 18737 s = -1; 18738 if ( (synpred125_Java()) ) {s = 43;} 18739 18740 else if ( (synpred126_Java()) ) {s = 5;} 18741 18742 18743 input.seek(index90_1); 18744 if ( s>=0 ) return s; 18745 break; 18746 case 1 : 18747 int LA90_2 = input.LA(1); 18748 18749 18750 int index90_2 = input.index(); 18751 input.rewind(); 18752 s = -1; 18753 if ( (synpred125_Java()) ) {s = 43;} 18754 18755 else if ( (synpred126_Java()) ) {s = 5;} 18756 18757 18758 input.seek(index90_2); 18759 if ( s>=0 ) return s; 18760 break; 18761 case 2 : 18762 int LA90_3 = input.LA(1); 18763 18764 18765 int index90_3 = input.index(); 18766 input.rewind(); 18767 s = -1; 18768 if ( (synpred125_Java()) ) {s = 43;} 18769 18770 else if ( (true) ) {s = 18;} 18771 18772 18773 input.seek(index90_3); 18774 if ( s>=0 ) return s; 18775 break; 18776 case 3 : 18777 int LA90_4 = input.LA(1); 18778 18779 18780 int index90_4 = input.index(); 18781 input.rewind(); 18782 s = -1; 18783 if ( (synpred125_Java()) ) {s = 43;} 18784 18785 else if ( (true) ) {s = 18;} 18786 18787 18788 input.seek(index90_4); 18789 if ( s>=0 ) return s; 18790 break; 18791 case 4 : 18792 int LA90_11 = input.LA(1); 18793 18794 18795 int index90_11 = input.index(); 18796 input.rewind(); 18797 s = -1; 18798 if ( (synpred126_Java()) ) {s = 5;} 18799 18800 else if ( (true) ) {s = 18;} 18801 18802 18803 input.seek(index90_11); 18804 if ( s>=0 ) return s; 18805 break; 18806 } 18807 if (state.backtracking>0) {state.failed=true; return -1;} 18808 NoViableAltException nvae = 18809 new NoViableAltException(getDescription(), 90, _s, input); 18810 error(nvae); 18811 throw nvae; 18812 } 18813 } 18814 static final String DFA98_eotS = 18815 "\40\uffff"; 18816 static final String DFA98_eofS = 18817 "\40\uffff"; 18818 static final String DFA98_minS = 18819 "\1\4\1\uffff\1\0\23\uffff\1\0\11\uffff"; 18820 static final String DFA98_maxS = 18821 "\1\143\1\uffff\1\0\23\uffff\1\0\11\uffff"; 18822 static final String DFA98_acceptS = 18823 "\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"+ 18824 "\15\1\16\1\17\15\uffff\1\21\1\2\1\3\1\20"; 18825 static final String DFA98_specialS = 18826 "\2\uffff\1\0\23\uffff\1\1\11\uffff}>"; 18827 static final String[] DFA98_transitionS = { 18828 "\1\26\11\16\17\uffff\1\2\1\16\1\14\1\16\2\uffff\1\16\2\uffff"+ 18829 "\1\15\1\uffff\1\6\1\16\5\uffff\1\16\1\4\1\uffff\1\3\3\uffff"+ 18830 "\1\16\1\uffff\1\16\1\uffff\1\16\4\uffff\1\12\1\16\2\uffff\1"+ 18831 "\16\1\10\1\11\1\16\1\13\2\uffff\1\7\1\16\1\uffff\1\5\1\16\1"+ 18832 "\uffff\1\1\3\uffff\1\34\4\uffff\2\16\5\uffff\4\16", 18833 "", 18834 "\1\uffff", 18835 "", 18836 "", 18837 "", 18838 "", 18839 "", 18840 "", 18841 "", 18842 "", 18843 "", 18844 "", 18845 "", 18846 "", 18847 "", 18848 "", 18849 "", 18850 "", 18851 "", 18852 "", 18853 "", 18854 "\1\uffff", 18855 "", 18856 "", 18857 "", 18858 "", 18859 "", 18860 "", 18861 "", 18862 "", 18863 "" 18864 }; 18865 18866 static final short[] DFA98_eot = DFA.unpackEncodedString(DFA98_eotS); 18867 static final short[] DFA98_eof = DFA.unpackEncodedString(DFA98_eofS); 18868 static final char[] DFA98_min = DFA.unpackEncodedStringToUnsignedChars(DFA98_minS); 18869 static final char[] DFA98_max = DFA.unpackEncodedStringToUnsignedChars(DFA98_maxS); 18870 static final short[] DFA98_accept = DFA.unpackEncodedString(DFA98_acceptS); 18871 static final short[] DFA98_special = DFA.unpackEncodedString(DFA98_specialS); 18872 static final short[][] DFA98_transition; 18873 18874 static { 18875 int numStates = DFA98_transitionS.length; 18876 DFA98_transition = new short[numStates][]; 18877 for (int i=0; i<numStates; i++) { 18878 DFA98_transition[i] = DFA.unpackEncodedString(DFA98_transitionS[i]); 18879 } 18880 } 18881 18882 class DFA98 extends DFA { 18883 DFA98(BaseRecognizer recognizer)18884 public DFA98(BaseRecognizer recognizer) { 18885 this.recognizer = recognizer; 18886 this.decisionNumber = 98; 18887 this.eot = DFA98_eot; 18888 this.eof = DFA98_eof; 18889 this.min = DFA98_min; 18890 this.max = DFA98_max; 18891 this.accept = DFA98_accept; 18892 this.special = DFA98_special; 18893 this.transition = DFA98_transition; 18894 } getDescription()18895 public String getDescription() { 18896 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 | ';' );"; 18897 } error(NoViableAltException nvae)18898 public void error(NoViableAltException nvae) { 18899 dbg.recognitionException(nvae); 18900 } specialStateTransition(int s, IntStream _input)18901 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 18902 TokenStream input = (TokenStream)_input; 18903 int _s = s; 18904 switch ( s ) { 18905 case 0 : 18906 int LA98_2 = input.LA(1); 18907 18908 18909 int index98_2 = input.index(); 18910 input.rewind(); 18911 s = -1; 18912 if ( (synpred130_Java()) ) {s = 29;} 18913 18914 else if ( (synpred132_Java()) ) {s = 30;} 18915 18916 18917 input.seek(index98_2); 18918 if ( s>=0 ) return s; 18919 break; 18920 case 1 : 18921 int LA98_22 = input.LA(1); 18922 18923 18924 int index98_22 = input.index(); 18925 input.rewind(); 18926 s = -1; 18927 if ( (synpred148_Java()) ) {s = 14;} 18928 18929 else if ( (synpred149_Java()) ) {s = 31;} 18930 18931 18932 input.seek(index98_22); 18933 if ( s>=0 ) return s; 18934 break; 18935 } 18936 if (state.backtracking>0) {state.failed=true; return -1;} 18937 NoViableAltException nvae = 18938 new NoViableAltException(getDescription(), 98, _s, input); 18939 error(nvae); 18940 throw nvae; 18941 } 18942 } 18943 static final String DFA109_eotS = 18944 "\21\uffff"; 18945 static final String DFA109_eofS = 18946 "\21\uffff"; 18947 static final String DFA109_minS = 18948 "\1\4\2\uffff\2\0\14\uffff"; 18949 static final String DFA109_maxS = 18950 "\1\162\2\uffff\2\0\14\uffff"; 18951 static final String DFA109_acceptS = 18952 "\1\uffff\1\1\3\uffff\1\2\13\uffff"; 18953 static final String DFA109_specialS = 18954 "\3\uffff\1\0\1\1\14\uffff}>"; 18955 static final String[] DFA109_transitionS = { 18956 "\1\3\11\5\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\3"+ 18957 "\uffff\1\1\1\uffff\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\5\5"+ 18958 "\uffff\1\4\2\uffff\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\12"+ 18959 "\uffff\2\5\5\uffff\4\5\16\uffff\1\1", 18960 "", 18961 "", 18962 "\1\uffff", 18963 "\1\uffff", 18964 "", 18965 "", 18966 "", 18967 "", 18968 "", 18969 "", 18970 "", 18971 "", 18972 "", 18973 "", 18974 "", 18975 "" 18976 }; 18977 18978 static final short[] DFA109_eot = DFA.unpackEncodedString(DFA109_eotS); 18979 static final short[] DFA109_eof = DFA.unpackEncodedString(DFA109_eofS); 18980 static final char[] DFA109_min = DFA.unpackEncodedStringToUnsignedChars(DFA109_minS); 18981 static final char[] DFA109_max = DFA.unpackEncodedStringToUnsignedChars(DFA109_maxS); 18982 static final short[] DFA109_accept = DFA.unpackEncodedString(DFA109_acceptS); 18983 static final short[] DFA109_special = DFA.unpackEncodedString(DFA109_specialS); 18984 static final short[][] DFA109_transition; 18985 18986 static { 18987 int numStates = DFA109_transitionS.length; 18988 DFA109_transition = new short[numStates][]; 18989 for (int i=0; i<numStates; i++) { 18990 DFA109_transition[i] = DFA.unpackEncodedString(DFA109_transitionS[i]); 18991 } 18992 } 18993 18994 class DFA109 extends DFA { 18995 DFA109(BaseRecognizer recognizer)18996 public DFA109(BaseRecognizer recognizer) { 18997 this.recognizer = recognizer; 18998 this.decisionNumber = 109; 18999 this.eot = DFA109_eot; 19000 this.eof = DFA109_eof; 19001 this.min = DFA109_min; 19002 this.max = DFA109_max; 19003 this.accept = DFA109_accept; 19004 this.special = DFA109_special; 19005 this.transition = DFA109_transition; 19006 } getDescription()19007 public String getDescription() { 19008 return "928:1: forInit : ( localVariableDeclaration | expressionList );"; 19009 } error(NoViableAltException nvae)19010 public void error(NoViableAltException nvae) { 19011 dbg.recognitionException(nvae); 19012 } specialStateTransition(int s, IntStream _input)19013 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19014 TokenStream input = (TokenStream)_input; 19015 int _s = s; 19016 switch ( s ) { 19017 case 0 : 19018 int LA109_3 = input.LA(1); 19019 19020 19021 int index109_3 = input.index(); 19022 input.rewind(); 19023 s = -1; 19024 if ( (synpred161_Java()) ) {s = 1;} 19025 19026 else if ( (true) ) {s = 5;} 19027 19028 19029 input.seek(index109_3); 19030 if ( s>=0 ) return s; 19031 break; 19032 case 1 : 19033 int LA109_4 = input.LA(1); 19034 19035 19036 int index109_4 = input.index(); 19037 input.rewind(); 19038 s = -1; 19039 if ( (synpred161_Java()) ) {s = 1;} 19040 19041 else if ( (true) ) {s = 5;} 19042 19043 19044 input.seek(index109_4); 19045 if ( s>=0 ) return s; 19046 break; 19047 } 19048 if (state.backtracking>0) {state.failed=true; return -1;} 19049 NoViableAltException nvae = 19050 new NoViableAltException(getDescription(), 109, _s, input); 19051 error(nvae); 19052 throw nvae; 19053 } 19054 } 19055 static final String DFA112_eotS = 19056 "\17\uffff"; 19057 static final String DFA112_eofS = 19058 "\17\uffff"; 19059 static final String DFA112_minS = 19060 "\1\130\12\uffff\1\164\1\130\2\uffff"; 19061 static final String DFA112_maxS = 19062 "\1\165\12\uffff\2\164\2\uffff"; 19063 static final String DFA112_acceptS = 19064 "\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"+ 19065 "\1\14"; 19066 static final String DFA112_specialS = 19067 "\17\uffff}>"; 19068 static final String[] DFA112_transitionS = { 19069 "\1\1\21\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\2\uffff\1\13"+ 19070 "\1\12", 19071 "", 19072 "", 19073 "", 19074 "", 19075 "", 19076 "", 19077 "", 19078 "", 19079 "", 19080 "", 19081 "\1\14", 19082 "\1\16\33\uffff\1\15", 19083 "", 19084 "" 19085 }; 19086 19087 static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS); 19088 static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS); 19089 static final char[] DFA112_min = DFA.unpackEncodedStringToUnsignedChars(DFA112_minS); 19090 static final char[] DFA112_max = DFA.unpackEncodedStringToUnsignedChars(DFA112_maxS); 19091 static final short[] DFA112_accept = DFA.unpackEncodedString(DFA112_acceptS); 19092 static final short[] DFA112_special = DFA.unpackEncodedString(DFA112_specialS); 19093 static final short[][] DFA112_transition; 19094 19095 static { 19096 int numStates = DFA112_transitionS.length; 19097 DFA112_transition = new short[numStates][]; 19098 for (int i=0; i<numStates; i++) { 19099 DFA112_transition[i] = DFA.unpackEncodedString(DFA112_transitionS[i]); 19100 } 19101 } 19102 19103 class DFA112 extends DFA { 19104 DFA112(BaseRecognizer recognizer)19105 public DFA112(BaseRecognizer recognizer) { 19106 this.recognizer = recognizer; 19107 this.decisionNumber = 112; 19108 this.eot = DFA112_eot; 19109 this.eof = DFA112_eof; 19110 this.min = DFA112_min; 19111 this.max = DFA112_max; 19112 this.accept = DFA112_accept; 19113 this.special = DFA112_special; 19114 this.transition = DFA112_transition; 19115 } getDescription()19116 public String getDescription() { 19117 return "951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );"; 19118 } error(NoViableAltException nvae)19119 public void error(NoViableAltException nvae) { 19120 dbg.recognitionException(nvae); 19121 } 19122 } 19123 static final String DFA130_eotS = 19124 "\14\uffff"; 19125 static final String DFA130_eofS = 19126 "\14\uffff"; 19127 static final String DFA130_minS = 19128 "\1\4\2\uffff\1\0\10\uffff"; 19129 static final String DFA130_maxS = 19130 "\1\132\2\uffff\1\0\10\uffff"; 19131 static final String DFA130_acceptS = 19132 "\1\uffff\1\1\1\2\1\uffff\1\4\6\uffff\1\3"; 19133 static final String DFA130_specialS = 19134 "\3\uffff\1\0\10\uffff}>"; 19135 static final String[] DFA130_transitionS = { 19136 "\12\4\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\5\uffff"+ 19137 "\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\4\5\uffff\1\4\2\uffff"+ 19138 "\1\4\2\uffff\1\4\4\uffff\1\4\2\uffff\1\3\12\uffff\1\2\1\1", 19139 "", 19140 "", 19141 "\1\uffff", 19142 "", 19143 "", 19144 "", 19145 "", 19146 "", 19147 "", 19148 "", 19149 "" 19150 }; 19151 19152 static final short[] DFA130_eot = DFA.unpackEncodedString(DFA130_eotS); 19153 static final short[] DFA130_eof = DFA.unpackEncodedString(DFA130_eofS); 19154 static final char[] DFA130_min = DFA.unpackEncodedStringToUnsignedChars(DFA130_minS); 19155 static final char[] DFA130_max = DFA.unpackEncodedStringToUnsignedChars(DFA130_maxS); 19156 static final short[] DFA130_accept = DFA.unpackEncodedString(DFA130_acceptS); 19157 static final short[] DFA130_special = DFA.unpackEncodedString(DFA130_specialS); 19158 static final short[][] DFA130_transition; 19159 19160 static { 19161 int numStates = DFA130_transitionS.length; 19162 DFA130_transition = new short[numStates][]; 19163 for (int i=0; i<numStates; i++) { 19164 DFA130_transition[i] = DFA.unpackEncodedString(DFA130_transitionS[i]); 19165 } 19166 } 19167 19168 class DFA130 extends DFA { 19169 DFA130(BaseRecognizer recognizer)19170 public DFA130(BaseRecognizer recognizer) { 19171 this.recognizer = recognizer; 19172 this.decisionNumber = 130; 19173 this.eot = DFA130_eot; 19174 this.eof = DFA130_eof; 19175 this.min = DFA130_min; 19176 this.max = DFA130_max; 19177 this.accept = DFA130_accept; 19178 this.special = DFA130_special; 19179 this.transition = DFA130_transition; 19180 } getDescription()19181 public String getDescription() { 19182 return "1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );"; 19183 } error(NoViableAltException nvae)19184 public void error(NoViableAltException nvae) { 19185 dbg.recognitionException(nvae); 19186 } specialStateTransition(int s, IntStream _input)19187 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19188 TokenStream input = (TokenStream)_input; 19189 int _s = s; 19190 switch ( s ) { 19191 case 0 : 19192 int LA130_3 = input.LA(1); 19193 19194 19195 int index130_3 = input.index(); 19196 input.rewind(); 19197 s = -1; 19198 if ( (synpred202_Java()) ) {s = 11;} 19199 19200 else if ( (true) ) {s = 4;} 19201 19202 19203 input.seek(index130_3); 19204 if ( s>=0 ) return s; 19205 break; 19206 } 19207 if (state.backtracking>0) {state.failed=true; return -1;} 19208 NoViableAltException nvae = 19209 new NoViableAltException(getDescription(), 130, _s, input); 19210 error(nvae); 19211 throw nvae; 19212 } 19213 } 19214 static final String DFA133_eotS = 19215 "\41\uffff"; 19216 static final String DFA133_eofS = 19217 "\1\4\40\uffff"; 19218 static final String DFA133_minS = 19219 "\1\65\1\0\1\uffff\1\0\35\uffff"; 19220 static final String DFA133_maxS = 19221 "\1\165\1\0\1\uffff\1\0\35\uffff"; 19222 static final String DFA133_acceptS = 19223 "\2\uffff\1\1\1\uffff\1\2\34\uffff"; 19224 static final String DFA133_specialS = 19225 "\1\uffff\1\0\1\uffff\1\1\35\uffff}>"; 19226 static final String[] DFA133_transitionS = { 19227 "\1\4\30\uffff\1\2\1\4\1\uffff\1\4\1\1\3\4\1\3\1\uffff\1\4\2"+ 19228 "\uffff\27\4\1\uffff\3\4", 19229 "\1\uffff", 19230 "", 19231 "\1\uffff", 19232 "", 19233 "", 19234 "", 19235 "", 19236 "", 19237 "", 19238 "", 19239 "", 19240 "", 19241 "", 19242 "", 19243 "", 19244 "", 19245 "", 19246 "", 19247 "", 19248 "", 19249 "", 19250 "", 19251 "", 19252 "", 19253 "", 19254 "", 19255 "", 19256 "", 19257 "", 19258 "", 19259 "", 19260 "" 19261 }; 19262 19263 static final short[] DFA133_eot = DFA.unpackEncodedString(DFA133_eotS); 19264 static final short[] DFA133_eof = DFA.unpackEncodedString(DFA133_eofS); 19265 static final char[] DFA133_min = DFA.unpackEncodedStringToUnsignedChars(DFA133_minS); 19266 static final char[] DFA133_max = DFA.unpackEncodedStringToUnsignedChars(DFA133_maxS); 19267 static final short[] DFA133_accept = DFA.unpackEncodedString(DFA133_acceptS); 19268 static final short[] DFA133_special = DFA.unpackEncodedString(DFA133_specialS); 19269 static final short[][] DFA133_transition; 19270 19271 static { 19272 int numStates = DFA133_transitionS.length; 19273 DFA133_transition = new short[numStates][]; 19274 for (int i=0; i<numStates; i++) { 19275 DFA133_transition[i] = DFA.unpackEncodedString(DFA133_transitionS[i]); 19276 } 19277 } 19278 19279 class DFA133 extends DFA { 19280 DFA133(BaseRecognizer recognizer)19281 public DFA133(BaseRecognizer recognizer) { 19282 this.recognizer = recognizer; 19283 this.decisionNumber = 133; 19284 this.eot = DFA133_eot; 19285 this.eof = DFA133_eof; 19286 this.min = DFA133_min; 19287 this.max = DFA133_max; 19288 this.accept = DFA133_accept; 19289 this.special = DFA133_special; 19290 this.transition = DFA133_transition; 19291 } getDescription()19292 public String getDescription() { 19293 return "1105:9: ( identifierSuffix )?"; 19294 } error(NoViableAltException nvae)19295 public void error(NoViableAltException nvae) { 19296 dbg.recognitionException(nvae); 19297 } specialStateTransition(int s, IntStream _input)19298 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19299 TokenStream input = (TokenStream)_input; 19300 int _s = s; 19301 switch ( s ) { 19302 case 0 : 19303 int LA133_1 = input.LA(1); 19304 19305 19306 int index133_1 = input.index(); 19307 input.rewind(); 19308 s = -1; 19309 if ( (synpred209_Java()) ) {s = 2;} 19310 19311 else if ( (true) ) {s = 4;} 19312 19313 19314 input.seek(index133_1); 19315 if ( s>=0 ) return s; 19316 break; 19317 case 1 : 19318 int LA133_3 = input.LA(1); 19319 19320 19321 int index133_3 = input.index(); 19322 input.rewind(); 19323 s = -1; 19324 if ( (synpred209_Java()) ) {s = 2;} 19325 19326 else if ( (true) ) {s = 4;} 19327 19328 19329 input.seek(index133_3); 19330 if ( s>=0 ) return s; 19331 break; 19332 } 19333 if (state.backtracking>0) {state.failed=true; return -1;} 19334 NoViableAltException nvae = 19335 new NoViableAltException(getDescription(), 133, _s, input); 19336 error(nvae); 19337 throw nvae; 19338 } 19339 } 19340 static final String DFA135_eotS = 19341 "\41\uffff"; 19342 static final String DFA135_eofS = 19343 "\1\4\40\uffff"; 19344 static final String DFA135_minS = 19345 "\1\65\1\0\1\uffff\1\0\35\uffff"; 19346 static final String DFA135_maxS = 19347 "\1\165\1\0\1\uffff\1\0\35\uffff"; 19348 static final String DFA135_acceptS = 19349 "\2\uffff\1\1\1\uffff\1\2\34\uffff"; 19350 static final String DFA135_specialS = 19351 "\1\uffff\1\0\1\uffff\1\1\35\uffff}>"; 19352 static final String[] DFA135_transitionS = { 19353 "\1\4\30\uffff\1\2\1\4\1\uffff\1\4\1\1\3\4\1\3\1\uffff\1\4\2"+ 19354 "\uffff\27\4\1\uffff\3\4", 19355 "\1\uffff", 19356 "", 19357 "\1\uffff", 19358 "", 19359 "", 19360 "", 19361 "", 19362 "", 19363 "", 19364 "", 19365 "", 19366 "", 19367 "", 19368 "", 19369 "", 19370 "", 19371 "", 19372 "", 19373 "", 19374 "", 19375 "", 19376 "", 19377 "", 19378 "", 19379 "", 19380 "", 19381 "", 19382 "", 19383 "", 19384 "", 19385 "", 19386 "" 19387 }; 19388 19389 static final short[] DFA135_eot = DFA.unpackEncodedString(DFA135_eotS); 19390 static final short[] DFA135_eof = DFA.unpackEncodedString(DFA135_eofS); 19391 static final char[] DFA135_min = DFA.unpackEncodedStringToUnsignedChars(DFA135_minS); 19392 static final char[] DFA135_max = DFA.unpackEncodedStringToUnsignedChars(DFA135_maxS); 19393 static final short[] DFA135_accept = DFA.unpackEncodedString(DFA135_acceptS); 19394 static final short[] DFA135_special = DFA.unpackEncodedString(DFA135_specialS); 19395 static final short[][] DFA135_transition; 19396 19397 static { 19398 int numStates = DFA135_transitionS.length; 19399 DFA135_transition = new short[numStates][]; 19400 for (int i=0; i<numStates; i++) { 19401 DFA135_transition[i] = DFA.unpackEncodedString(DFA135_transitionS[i]); 19402 } 19403 } 19404 19405 class DFA135 extends DFA { 19406 DFA135(BaseRecognizer recognizer)19407 public DFA135(BaseRecognizer recognizer) { 19408 this.recognizer = recognizer; 19409 this.decisionNumber = 135; 19410 this.eot = DFA135_eot; 19411 this.eof = DFA135_eof; 19412 this.min = DFA135_min; 19413 this.max = DFA135_max; 19414 this.accept = DFA135_accept; 19415 this.special = DFA135_special; 19416 this.transition = DFA135_transition; 19417 } getDescription()19418 public String getDescription() { 19419 return "1110:9: ( identifierSuffix )?"; 19420 } error(NoViableAltException nvae)19421 public void error(NoViableAltException nvae) { 19422 dbg.recognitionException(nvae); 19423 } specialStateTransition(int s, IntStream _input)19424 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19425 TokenStream input = (TokenStream)_input; 19426 int _s = s; 19427 switch ( s ) { 19428 case 0 : 19429 int LA135_1 = input.LA(1); 19430 19431 19432 int index135_1 = input.index(); 19433 input.rewind(); 19434 s = -1; 19435 if ( (synpred212_Java()) ) {s = 2;} 19436 19437 else if ( (true) ) {s = 4;} 19438 19439 19440 input.seek(index135_1); 19441 if ( s>=0 ) return s; 19442 break; 19443 case 1 : 19444 int LA135_3 = input.LA(1); 19445 19446 19447 int index135_3 = input.index(); 19448 input.rewind(); 19449 s = -1; 19450 if ( (synpred212_Java()) ) {s = 2;} 19451 19452 else if ( (true) ) {s = 4;} 19453 19454 19455 input.seek(index135_3); 19456 if ( s>=0 ) return s; 19457 break; 19458 } 19459 if (state.backtracking>0) {state.failed=true; return -1;} 19460 NoViableAltException nvae = 19461 new NoViableAltException(getDescription(), 135, _s, input); 19462 error(nvae); 19463 throw nvae; 19464 } 19465 } 19466 static final String DFA143_eotS = 19467 "\13\uffff"; 19468 static final String DFA143_eofS = 19469 "\13\uffff"; 19470 static final String DFA143_minS = 19471 "\1\116\1\4\1\uffff\1\44\7\uffff"; 19472 static final String DFA143_maxS = 19473 "\1\126\1\143\1\uffff\1\165\7\uffff"; 19474 static final String DFA143_acceptS = 19475 "\2\uffff\1\3\1\uffff\1\1\1\2\1\4\1\6\1\7\1\10\1\5"; 19476 static final String DFA143_specialS = 19477 "\13\uffff}>"; 19478 static final String[] DFA143_transitionS = { 19479 "\1\2\3\uffff\1\1\3\uffff\1\3", 19480 "\12\5\20\uffff\1\5\1\uffff\1\5\2\uffff\1\5\5\uffff\1\5\5\uffff"+ 19481 "\1\5\6\uffff\1\5\1\uffff\1\5\1\uffff\1\5\5\uffff\1\5\2\uffff"+ 19482 "\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\4\uffff\1\4\5\uffff"+ 19483 "\2\5\5\uffff\4\5", 19484 "", 19485 "\1\6\25\uffff\1\11\10\uffff\1\10\2\uffff\1\7\56\uffff\1\12", 19486 "", 19487 "", 19488 "", 19489 "", 19490 "", 19491 "", 19492 "" 19493 }; 19494 19495 static final short[] DFA143_eot = DFA.unpackEncodedString(DFA143_eotS); 19496 static final short[] DFA143_eof = DFA.unpackEncodedString(DFA143_eofS); 19497 static final char[] DFA143_min = DFA.unpackEncodedStringToUnsignedChars(DFA143_minS); 19498 static final char[] DFA143_max = DFA.unpackEncodedStringToUnsignedChars(DFA143_maxS); 19499 static final short[] DFA143_accept = DFA.unpackEncodedString(DFA143_acceptS); 19500 static final short[] DFA143_special = DFA.unpackEncodedString(DFA143_specialS); 19501 static final short[][] DFA143_transition; 19502 19503 static { 19504 int numStates = DFA143_transitionS.length; 19505 DFA143_transition = new short[numStates][]; 19506 for (int i=0; i<numStates; i++) { 19507 DFA143_transition[i] = DFA.unpackEncodedString(DFA143_transitionS[i]); 19508 } 19509 } 19510 19511 class DFA143 extends DFA { 19512 DFA143(BaseRecognizer recognizer)19513 public DFA143(BaseRecognizer recognizer) { 19514 this.recognizer = recognizer; 19515 this.decisionNumber = 143; 19516 this.eot = DFA143_eot; 19517 this.eof = DFA143_eof; 19518 this.min = DFA143_min; 19519 this.max = DFA143_max; 19520 this.accept = DFA143_accept; 19521 this.special = DFA143_special; 19522 this.transition = DFA143_transition; 19523 } getDescription()19524 public String getDescription() { 19525 return "1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );"; 19526 } error(NoViableAltException nvae)19527 public void error(NoViableAltException nvae) { 19528 dbg.recognitionException(nvae); 19529 } 19530 } 19531 static final String DFA142_eotS = 19532 "\41\uffff"; 19533 static final String DFA142_eofS = 19534 "\1\1\40\uffff"; 19535 static final String DFA142_minS = 19536 "\1\65\1\uffff\1\0\36\uffff"; 19537 static final String DFA142_maxS = 19538 "\1\165\1\uffff\1\0\36\uffff"; 19539 static final String DFA142_acceptS = 19540 "\1\uffff\1\2\36\uffff\1\1"; 19541 static final String DFA142_specialS = 19542 "\2\uffff\1\0\36\uffff}>"; 19543 static final String[] DFA142_transitionS = { 19544 "\1\1\31\uffff\1\1\1\uffff\1\1\1\2\4\1\1\uffff\1\1\2\uffff\27"+ 19545 "\1\1\uffff\3\1", 19546 "", 19547 "\1\uffff", 19548 "", 19549 "", 19550 "", 19551 "", 19552 "", 19553 "", 19554 "", 19555 "", 19556 "", 19557 "", 19558 "", 19559 "", 19560 "", 19561 "", 19562 "", 19563 "", 19564 "", 19565 "", 19566 "", 19567 "", 19568 "", 19569 "", 19570 "", 19571 "", 19572 "", 19573 "", 19574 "", 19575 "", 19576 "", 19577 "" 19578 }; 19579 19580 static final short[] DFA142_eot = DFA.unpackEncodedString(DFA142_eotS); 19581 static final short[] DFA142_eof = DFA.unpackEncodedString(DFA142_eofS); 19582 static final char[] DFA142_min = DFA.unpackEncodedStringToUnsignedChars(DFA142_minS); 19583 static final char[] DFA142_max = DFA.unpackEncodedStringToUnsignedChars(DFA142_maxS); 19584 static final short[] DFA142_accept = DFA.unpackEncodedString(DFA142_acceptS); 19585 static final short[] DFA142_special = DFA.unpackEncodedString(DFA142_specialS); 19586 static final short[][] DFA142_transition; 19587 19588 static { 19589 int numStates = DFA142_transitionS.length; 19590 DFA142_transition = new short[numStates][]; 19591 for (int i=0; i<numStates; i++) { 19592 DFA142_transition[i] = DFA.unpackEncodedString(DFA142_transitionS[i]); 19593 } 19594 } 19595 19596 class DFA142 extends DFA { 19597 DFA142(BaseRecognizer recognizer)19598 public DFA142(BaseRecognizer recognizer) { 19599 this.recognizer = recognizer; 19600 this.decisionNumber = 142; 19601 this.eot = DFA142_eot; 19602 this.eof = DFA142_eof; 19603 this.min = DFA142_min; 19604 this.max = DFA142_max; 19605 this.accept = DFA142_accept; 19606 this.special = DFA142_special; 19607 this.transition = DFA142_transition; 19608 } getDescription()19609 public String getDescription() { 19610 return "()+ loopback of 1138:9: ( '[' expression ']' )+"; 19611 } error(NoViableAltException nvae)19612 public void error(NoViableAltException nvae) { 19613 dbg.recognitionException(nvae); 19614 } specialStateTransition(int s, IntStream _input)19615 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19616 TokenStream input = (TokenStream)_input; 19617 int _s = s; 19618 switch ( s ) { 19619 case 0 : 19620 int LA142_2 = input.LA(1); 19621 19622 19623 int index142_2 = input.index(); 19624 input.rewind(); 19625 s = -1; 19626 if ( (synpred224_Java()) ) {s = 32;} 19627 19628 else if ( (true) ) {s = 1;} 19629 19630 19631 input.seek(index142_2); 19632 if ( s>=0 ) return s; 19633 break; 19634 } 19635 if (state.backtracking>0) {state.failed=true; return -1;} 19636 NoViableAltException nvae = 19637 new NoViableAltException(getDescription(), 142, _s, input); 19638 error(nvae); 19639 throw nvae; 19640 } 19641 } 19642 static final String DFA148_eotS = 19643 "\41\uffff"; 19644 static final String DFA148_eofS = 19645 "\1\2\40\uffff"; 19646 static final String DFA148_minS = 19647 "\1\65\1\0\37\uffff"; 19648 static final String DFA148_maxS = 19649 "\1\165\1\0\37\uffff"; 19650 static final String DFA148_acceptS = 19651 "\2\uffff\1\2\35\uffff\1\1"; 19652 static final String DFA148_specialS = 19653 "\1\uffff\1\0\37\uffff}>"; 19654 static final String[] DFA148_transitionS = { 19655 "\1\2\31\uffff\1\2\1\uffff\1\2\1\1\4\2\1\uffff\1\2\2\uffff\27"+ 19656 "\2\1\uffff\3\2", 19657 "\1\uffff", 19658 "", 19659 "", 19660 "", 19661 "", 19662 "", 19663 "", 19664 "", 19665 "", 19666 "", 19667 "", 19668 "", 19669 "", 19670 "", 19671 "", 19672 "", 19673 "", 19674 "", 19675 "", 19676 "", 19677 "", 19678 "", 19679 "", 19680 "", 19681 "", 19682 "", 19683 "", 19684 "", 19685 "", 19686 "", 19687 "", 19688 "" 19689 }; 19690 19691 static final short[] DFA148_eot = DFA.unpackEncodedString(DFA148_eotS); 19692 static final short[] DFA148_eof = DFA.unpackEncodedString(DFA148_eofS); 19693 static final char[] DFA148_min = DFA.unpackEncodedStringToUnsignedChars(DFA148_minS); 19694 static final char[] DFA148_max = DFA.unpackEncodedStringToUnsignedChars(DFA148_maxS); 19695 static final short[] DFA148_accept = DFA.unpackEncodedString(DFA148_acceptS); 19696 static final short[] DFA148_special = DFA.unpackEncodedString(DFA148_specialS); 19697 static final short[][] DFA148_transition; 19698 19699 static { 19700 int numStates = DFA148_transitionS.length; 19701 DFA148_transition = new short[numStates][]; 19702 for (int i=0; i<numStates; i++) { 19703 DFA148_transition[i] = DFA.unpackEncodedString(DFA148_transitionS[i]); 19704 } 19705 } 19706 19707 class DFA148 extends DFA { 19708 DFA148(BaseRecognizer recognizer)19709 public DFA148(BaseRecognizer recognizer) { 19710 this.recognizer = recognizer; 19711 this.decisionNumber = 148; 19712 this.eot = DFA148_eot; 19713 this.eof = DFA148_eof; 19714 this.min = DFA148_min; 19715 this.max = DFA148_max; 19716 this.accept = DFA148_accept; 19717 this.special = DFA148_special; 19718 this.transition = DFA148_transition; 19719 } getDescription()19720 public String getDescription() { 19721 return "()* loopback of 1176:9: ( '[' expression ']' )*"; 19722 } error(NoViableAltException nvae)19723 public void error(NoViableAltException nvae) { 19724 dbg.recognitionException(nvae); 19725 } specialStateTransition(int s, IntStream _input)19726 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19727 TokenStream input = (TokenStream)_input; 19728 int _s = s; 19729 switch ( s ) { 19730 case 0 : 19731 int LA148_1 = input.LA(1); 19732 19733 19734 int index148_1 = input.index(); 19735 input.rewind(); 19736 s = -1; 19737 if ( (synpred240_Java()) ) {s = 32;} 19738 19739 else if ( (true) ) {s = 2;} 19740 19741 19742 input.seek(index148_1); 19743 if ( s>=0 ) return s; 19744 break; 19745 } 19746 if (state.backtracking>0) {state.failed=true; return -1;} 19747 NoViableAltException nvae = 19748 new NoViableAltException(getDescription(), 148, _s, input); 19749 error(nvae); 19750 throw nvae; 19751 } 19752 } 19753 static final String DFA171_eotS = 19754 "\55\uffff"; 19755 static final String DFA171_eofS = 19756 "\55\uffff"; 19757 static final String DFA171_minS = 19758 "\1\4\1\uffff\10\0\43\uffff"; 19759 static final String DFA171_maxS = 19760 "\1\165\1\uffff\10\0\43\uffff"; 19761 static final String DFA171_acceptS = 19762 "\1\uffff\1\1\10\uffff\1\2\42\uffff"; 19763 static final String DFA171_specialS = 19764 "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>"; 19765 static final String[] DFA171_transitionS = { 19766 "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+ 19767 "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+ 19768 "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+ 19769 "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+ 19770 "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+ 19771 "\1\12\2\uffff\1\1", 19772 "", 19773 "\1\uffff", 19774 "\1\uffff", 19775 "\1\uffff", 19776 "\1\uffff", 19777 "\1\uffff", 19778 "\1\uffff", 19779 "\1\uffff", 19780 "\1\uffff", 19781 "", 19782 "", 19783 "", 19784 "", 19785 "", 19786 "", 19787 "", 19788 "", 19789 "", 19790 "", 19791 "", 19792 "", 19793 "", 19794 "", 19795 "", 19796 "", 19797 "", 19798 "", 19799 "", 19800 "", 19801 "", 19802 "", 19803 "", 19804 "", 19805 "", 19806 "", 19807 "", 19808 "", 19809 "", 19810 "", 19811 "", 19812 "", 19813 "", 19814 "", 19815 "" 19816 }; 19817 19818 static final short[] DFA171_eot = DFA.unpackEncodedString(DFA171_eotS); 19819 static final short[] DFA171_eof = DFA.unpackEncodedString(DFA171_eofS); 19820 static final char[] DFA171_min = DFA.unpackEncodedStringToUnsignedChars(DFA171_minS); 19821 static final char[] DFA171_max = DFA.unpackEncodedStringToUnsignedChars(DFA171_maxS); 19822 static final short[] DFA171_accept = DFA.unpackEncodedString(DFA171_acceptS); 19823 static final short[] DFA171_special = DFA.unpackEncodedString(DFA171_specialS); 19824 static final short[][] DFA171_transition; 19825 19826 static { 19827 int numStates = DFA171_transitionS.length; 19828 DFA171_transition = new short[numStates][]; 19829 for (int i=0; i<numStates; i++) { 19830 DFA171_transition[i] = DFA.unpackEncodedString(DFA171_transitionS[i]); 19831 } 19832 } 19833 19834 class DFA171 extends DFA { 19835 DFA171(BaseRecognizer recognizer)19836 public DFA171(BaseRecognizer recognizer) { 19837 this.recognizer = recognizer; 19838 this.decisionNumber = 171; 19839 this.eot = DFA171_eot; 19840 this.eof = DFA171_eof; 19841 this.min = DFA171_min; 19842 this.max = DFA171_max; 19843 this.accept = DFA171_accept; 19844 this.special = DFA171_special; 19845 this.transition = DFA171_transition; 19846 } getDescription()19847 public String getDescription() { 19848 return "521:9: ( explicitConstructorInvocation )?"; 19849 } error(NoViableAltException nvae)19850 public void error(NoViableAltException nvae) { 19851 dbg.recognitionException(nvae); 19852 } specialStateTransition(int s, IntStream _input)19853 public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { 19854 TokenStream input = (TokenStream)_input; 19855 int _s = s; 19856 switch ( s ) { 19857 case 0 : 19858 int LA171_2 = input.LA(1); 19859 19860 19861 int index171_2 = input.index(); 19862 input.rewind(); 19863 s = -1; 19864 if ( (synpred57_Java()) ) {s = 1;} 19865 19866 else if ( (true) ) {s = 10;} 19867 19868 19869 input.seek(index171_2); 19870 if ( s>=0 ) return s; 19871 break; 19872 case 1 : 19873 int LA171_3 = input.LA(1); 19874 19875 19876 int index171_3 = input.index(); 19877 input.rewind(); 19878 s = -1; 19879 if ( (synpred57_Java()) ) {s = 1;} 19880 19881 else if ( (true) ) {s = 10;} 19882 19883 19884 input.seek(index171_3); 19885 if ( s>=0 ) return s; 19886 break; 19887 case 2 : 19888 int LA171_4 = input.LA(1); 19889 19890 19891 int index171_4 = input.index(); 19892 input.rewind(); 19893 s = -1; 19894 if ( (synpred57_Java()) ) {s = 1;} 19895 19896 else if ( (true) ) {s = 10;} 19897 19898 19899 input.seek(index171_4); 19900 if ( s>=0 ) return s; 19901 break; 19902 case 3 : 19903 int LA171_5 = input.LA(1); 19904 19905 19906 int index171_5 = input.index(); 19907 input.rewind(); 19908 s = -1; 19909 if ( (synpred57_Java()) ) {s = 1;} 19910 19911 else if ( (true) ) {s = 10;} 19912 19913 19914 input.seek(index171_5); 19915 if ( s>=0 ) return s; 19916 break; 19917 case 4 : 19918 int LA171_6 = input.LA(1); 19919 19920 19921 int index171_6 = input.index(); 19922 input.rewind(); 19923 s = -1; 19924 if ( (synpred57_Java()) ) {s = 1;} 19925 19926 else if ( (true) ) {s = 10;} 19927 19928 19929 input.seek(index171_6); 19930 if ( s>=0 ) return s; 19931 break; 19932 case 5 : 19933 int LA171_7 = input.LA(1); 19934 19935 19936 int index171_7 = input.index(); 19937 input.rewind(); 19938 s = -1; 19939 if ( (synpred57_Java()) ) {s = 1;} 19940 19941 else if ( (true) ) {s = 10;} 19942 19943 19944 input.seek(index171_7); 19945 if ( s>=0 ) return s; 19946 break; 19947 case 6 : 19948 int LA171_8 = input.LA(1); 19949 19950 19951 int index171_8 = input.index(); 19952 input.rewind(); 19953 s = -1; 19954 if ( (synpred57_Java()) ) {s = 1;} 19955 19956 else if ( (true) ) {s = 10;} 19957 19958 19959 input.seek(index171_8); 19960 if ( s>=0 ) return s; 19961 break; 19962 case 7 : 19963 int LA171_9 = input.LA(1); 19964 19965 19966 int index171_9 = input.index(); 19967 input.rewind(); 19968 s = -1; 19969 if ( (synpred57_Java()) ) {s = 1;} 19970 19971 else if ( (true) ) {s = 10;} 19972 19973 19974 input.seek(index171_9); 19975 if ( s>=0 ) return s; 19976 break; 19977 } 19978 if (state.backtracking>0) {state.failed=true; return -1;} 19979 NoViableAltException nvae = 19980 new NoViableAltException(getDescription(), 171, _s, input); 19981 error(nvae); 19982 throw nvae; 19983 } 19984 } 19985 19986 19987 public static final BitSet FOLLOW_annotations_in_compilationUnit64 = new BitSet(new long[]{0x0800000000000000L}); 19988 public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit93 = new BitSet(new long[]{0x7290281010000002L,0x0004000000101226L}); 19989 public static final BitSet FOLLOW_importDeclaration_in_compilationUnit115 = new BitSet(new long[]{0x7290281010000002L,0x0004000000101226L}); 19990 public static final BitSet FOLLOW_typeDeclaration_in_compilationUnit137 = new BitSet(new long[]{0x7280281010000002L,0x0004000000101226L}); 19991 public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration167 = new BitSet(new long[]{0x0000000000000010L}); 19992 public static final BitSet FOLLOW_qualifiedName_in_packageDeclaration169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 19993 public static final BitSet FOLLOW_SEMI_in_packageDeclaration179 = new BitSet(new long[]{0x0000000000000002L}); 19994 public static final BitSet FOLLOW_IMPORT_in_importDeclaration198 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000002L}); 19995 public static final BitSet FOLLOW_STATIC_in_importDeclaration209 = new BitSet(new long[]{0x0000000000000010L}); 19996 public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration230 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); 19997 public static final BitSet FOLLOW_DOT_in_importDeclaration232 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); 19998 public static final BitSet FOLLOW_STAR_in_importDeclaration234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 19999 public static final BitSet FOLLOW_SEMI_in_importDeclaration244 = new BitSet(new long[]{0x0000000000000002L}); 20000 public static final BitSet FOLLOW_IMPORT_in_importDeclaration254 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000002L}); 20001 public static final BitSet FOLLOW_STATIC_in_importDeclaration265 = new BitSet(new long[]{0x0000000000000010L}); 20002 public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration286 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); 20003 public static final BitSet FOLLOW_DOT_in_importDeclaration297 = new BitSet(new long[]{0x0000000000000010L}); 20004 public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration299 = new BitSet(new long[]{0x0000000000000000L,0x0000000000500000L}); 20005 public static final BitSet FOLLOW_DOT_in_importDeclaration321 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); 20006 public static final BitSet FOLLOW_STAR_in_importDeclaration323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20007 public static final BitSet FOLLOW_SEMI_in_importDeclaration344 = new BitSet(new long[]{0x0000000000000002L}); 20008 public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName363 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); 20009 public static final BitSet FOLLOW_DOT_in_qualifiedImportName374 = new BitSet(new long[]{0x0000000000000010L}); 20010 public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName376 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); 20011 public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406 = new BitSet(new long[]{0x0000000000000002L}); 20012 public static final BitSet FOLLOW_SEMI_in_typeDeclaration416 = new BitSet(new long[]{0x0000000000000002L}); 20013 public static final BitSet FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436 = new BitSet(new long[]{0x0000000000000002L}); 20014 public static final BitSet FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446 = new BitSet(new long[]{0x0000000000000002L}); 20015 public static final BitSet FOLLOW_annotation_in_modifiers473 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20016 public static final BitSet FOLLOW_PUBLIC_in_modifiers483 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20017 public static final BitSet FOLLOW_PROTECTED_in_modifiers493 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20018 public static final BitSet FOLLOW_PRIVATE_in_modifiers503 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20019 public static final BitSet FOLLOW_STATIC_in_modifiers513 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20020 public static final BitSet FOLLOW_ABSTRACT_in_modifiers523 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20021 public static final BitSet FOLLOW_FINAL_in_modifiers533 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20022 public static final BitSet FOLLOW_NATIVE_in_modifiers543 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20023 public static final BitSet FOLLOW_SYNCHRONIZED_in_modifiers553 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20024 public static final BitSet FOLLOW_TRANSIENT_in_modifiers563 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20025 public static final BitSet FOLLOW_VOLATILE_in_modifiers573 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20026 public static final BitSet FOLLOW_STRICTFP_in_modifiers583 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L}); 20027 public static final BitSet FOLLOW_FINAL_in_variableModifiers614 = new BitSet(new long[]{0x0000200000000002L,0x0004000000000000L}); 20028 public static final BitSet FOLLOW_annotation_in_variableModifiers628 = new BitSet(new long[]{0x0000200000000002L,0x0004000000000000L}); 20029 public static final BitSet FOLLOW_normalClassDeclaration_in_classDeclaration659 = new BitSet(new long[]{0x0000000000000002L}); 20030 public static final BitSet FOLLOW_enumDeclaration_in_classDeclaration669 = new BitSet(new long[]{0x0000000000000002L}); 20031 public static final BitSet FOLLOW_modifiers_in_normalClassDeclaration688 = new BitSet(new long[]{0x0000001000000000L}); 20032 public static final BitSet FOLLOW_CLASS_in_normalClassDeclaration691 = new BitSet(new long[]{0x0000000000000010L}); 20033 public static final BitSet FOLLOW_IDENTIFIER_in_normalClassDeclaration693 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); 20034 public static final BitSet FOLLOW_typeParameters_in_normalClassDeclaration704 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); 20035 public static final BitSet FOLLOW_EXTENDS_in_normalClassDeclaration726 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20036 public static final BitSet FOLLOW_type_in_normalClassDeclaration728 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); 20037 public static final BitSet FOLLOW_IMPLEMENTS_in_normalClassDeclaration750 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20038 public static final BitSet FOLLOW_typeList_in_normalClassDeclaration752 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L}); 20039 public static final BitSet FOLLOW_classBody_in_normalClassDeclaration773 = new BitSet(new long[]{0x0000000000000002L}); 20040 public static final BitSet FOLLOW_LT_in_typeParameters793 = new BitSet(new long[]{0x0000000000000010L}); 20041 public static final BitSet FOLLOW_typeParameter_in_typeParameters807 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); 20042 public static final BitSet FOLLOW_COMMA_in_typeParameters822 = new BitSet(new long[]{0x0000000000000010L}); 20043 public static final BitSet FOLLOW_typeParameter_in_typeParameters824 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); 20044 public static final BitSet FOLLOW_GT_in_typeParameters849 = new BitSet(new long[]{0x0000000000000002L}); 20045 public static final BitSet FOLLOW_IDENTIFIER_in_typeParameter868 = new BitSet(new long[]{0x0000100000000002L}); 20046 public static final BitSet FOLLOW_EXTENDS_in_typeParameter879 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20047 public static final BitSet FOLLOW_typeBound_in_typeParameter881 = new BitSet(new long[]{0x0000000000000002L}); 20048 public static final BitSet FOLLOW_type_in_typeBound912 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); 20049 public static final BitSet FOLLOW_AMP_in_typeBound923 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20050 public static final BitSet FOLLOW_type_in_typeBound925 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); 20051 public static final BitSet FOLLOW_modifiers_in_enumDeclaration956 = new BitSet(new long[]{0x0000080000000000L}); 20052 public static final BitSet FOLLOW_ENUM_in_enumDeclaration967 = new BitSet(new long[]{0x0000000000000010L}); 20053 public static final BitSet FOLLOW_IDENTIFIER_in_enumDeclaration987 = new BitSet(new long[]{0x0008000000000000L,0x0000000000010000L}); 20054 public static final BitSet FOLLOW_IMPLEMENTS_in_enumDeclaration998 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20055 public static final BitSet FOLLOW_typeList_in_enumDeclaration1000 = new BitSet(new long[]{0x0008000000000000L,0x0000000000010000L}); 20056 public static final BitSet FOLLOW_enumBody_in_enumDeclaration1021 = new BitSet(new long[]{0x0000000000000002L}); 20057 public static final BitSet FOLLOW_LBRACE_in_enumBody1041 = new BitSet(new long[]{0x0000000000000010L,0x0004000000320000L}); 20058 public static final BitSet FOLLOW_enumConstants_in_enumBody1052 = new BitSet(new long[]{0x0000000000000000L,0x0000000000320000L}); 20059 public static final BitSet FOLLOW_COMMA_in_enumBody1073 = new BitSet(new long[]{0x0000000000000000L,0x0000000000120000L}); 20060 public static final BitSet FOLLOW_enumBodyDeclarations_in_enumBody1085 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); 20061 public static final BitSet FOLLOW_RBRACE_in_enumBody1106 = new BitSet(new long[]{0x0000000000000002L}); 20062 public static final BitSet FOLLOW_enumConstant_in_enumConstants1125 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20063 public static final BitSet FOLLOW_COMMA_in_enumConstants1136 = new BitSet(new long[]{0x0000000000000010L,0x0004000000000000L}); 20064 public static final BitSet FOLLOW_enumConstant_in_enumConstants1138 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20065 public static final BitSet FOLLOW_annotations_in_enumConstant1171 = new BitSet(new long[]{0x0000000000000010L}); 20066 public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant1192 = new BitSet(new long[]{0x0008100000000002L,0x0020000000014000L}); 20067 public static final BitSet FOLLOW_arguments_in_enumConstant1203 = new BitSet(new long[]{0x0008100000000002L,0x0020000000010000L}); 20068 public static final BitSet FOLLOW_classBody_in_enumConstant1225 = new BitSet(new long[]{0x0000000000000002L}); 20069 public static final BitSet FOLLOW_SEMI_in_enumBodyDeclarations1265 = new BitSet(new long[]{0x73C0AA1950000012L,0x0024000000111A27L}); 20070 public static final BitSet FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276 = new BitSet(new long[]{0x73C0AA1950000012L,0x0024000000111A27L}); 20071 public static final BitSet FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306 = new BitSet(new long[]{0x0000000000000002L}); 20072 public static final BitSet FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316 = new BitSet(new long[]{0x0000000000000002L}); 20073 public static final BitSet FOLLOW_modifiers_in_normalInterfaceDeclaration1335 = new BitSet(new long[]{0x0080000000000000L}); 20074 public static final BitSet FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337 = new BitSet(new long[]{0x0000000000000010L}); 20075 public static final BitSet FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L}); 20076 public static final BitSet FOLLOW_typeParameters_in_normalInterfaceDeclaration1350 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L}); 20077 public static final BitSet FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20078 public static final BitSet FOLLOW_typeList_in_normalInterfaceDeclaration1374 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L}); 20079 public static final BitSet FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395 = new BitSet(new long[]{0x0000000000000002L}); 20080 public static final BitSet FOLLOW_type_in_typeList1414 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20081 public static final BitSet FOLLOW_COMMA_in_typeList1425 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20082 public static final BitSet FOLLOW_type_in_typeList1427 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20083 public static final BitSet FOLLOW_LBRACE_in_classBody1457 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000131A27L}); 20084 public static final BitSet FOLLOW_classBodyDeclaration_in_classBody1468 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000131A27L}); 20085 public static final BitSet FOLLOW_RBRACE_in_classBody1489 = new BitSet(new long[]{0x0000000000000002L}); 20086 public static final BitSet FOLLOW_LBRACE_in_interfaceBody1508 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000121A27L}); 20087 public static final BitSet FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000121A27L}); 20088 public static final BitSet FOLLOW_RBRACE_in_interfaceBody1540 = new BitSet(new long[]{0x0000000000000002L}); 20089 public static final BitSet FOLLOW_SEMI_in_classBodyDeclaration1559 = new BitSet(new long[]{0x0000000000000002L}); 20090 public static final BitSet FOLLOW_STATIC_in_classBodyDeclaration1570 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20091 public static final BitSet FOLLOW_block_in_classBodyDeclaration1591 = new BitSet(new long[]{0x0000000000000002L}); 20092 public static final BitSet FOLLOW_memberDecl_in_classBodyDeclaration1601 = new BitSet(new long[]{0x0000000000000002L}); 20093 public static final BitSet FOLLOW_fieldDeclaration_in_memberDecl1621 = new BitSet(new long[]{0x0000000000000002L}); 20094 public static final BitSet FOLLOW_methodDeclaration_in_memberDecl1632 = new BitSet(new long[]{0x0000000000000002L}); 20095 public static final BitSet FOLLOW_classDeclaration_in_memberDecl1643 = new BitSet(new long[]{0x0000000000000002L}); 20096 public static final BitSet FOLLOW_interfaceDeclaration_in_memberDecl1654 = new BitSet(new long[]{0x0000000000000002L}); 20097 public static final BitSet FOLLOW_modifiers_in_methodDeclaration1691 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); 20098 public static final BitSet FOLLOW_typeParameters_in_methodDeclaration1702 = new BitSet(new long[]{0x0000000000000010L}); 20099 public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration1723 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20100 public static final BitSet FOLLOW_formalParameters_in_methodDeclaration1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010100L}); 20101 public static final BitSet FOLLOW_THROWS_in_methodDeclaration1744 = new BitSet(new long[]{0x0000000000000010L}); 20102 public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration1746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); 20103 public static final BitSet FOLLOW_LBRACE_in_methodDeclaration1767 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20104 public static final BitSet FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20105 public static final BitSet FOLLOW_blockStatement_in_methodDeclaration1800 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20106 public static final BitSet FOLLOW_RBRACE_in_methodDeclaration1821 = new BitSet(new long[]{0x0000000000000002L}); 20107 public static final BitSet FOLLOW_modifiers_in_methodDeclaration1831 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L}); 20108 public static final BitSet FOLLOW_typeParameters_in_methodDeclaration1842 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L}); 20109 public static final BitSet FOLLOW_type_in_methodDeclaration1864 = new BitSet(new long[]{0x0000000000000010L}); 20110 public static final BitSet FOLLOW_VOID_in_methodDeclaration1878 = new BitSet(new long[]{0x0000000000000010L}); 20111 public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration1898 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20112 public static final BitSet FOLLOW_formalParameters_in_methodDeclaration1908 = new BitSet(new long[]{0x0000000000000000L,0x0000000000150102L}); 20113 public static final BitSet FOLLOW_LBRACKET_in_methodDeclaration1919 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20114 public static final BitSet FOLLOW_RBRACKET_in_methodDeclaration1921 = new BitSet(new long[]{0x0000000000000000L,0x0000000000150102L}); 20115 public static final BitSet FOLLOW_THROWS_in_methodDeclaration1943 = new BitSet(new long[]{0x0000000000000010L}); 20116 public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration1945 = new BitSet(new long[]{0x0000000000000000L,0x0000000000110002L}); 20117 public static final BitSet FOLLOW_block_in_methodDeclaration1980 = new BitSet(new long[]{0x0000000000000002L}); 20118 public static final BitSet FOLLOW_SEMI_in_methodDeclaration1994 = new BitSet(new long[]{0x0000000000000002L}); 20119 public static final BitSet FOLLOW_modifiers_in_fieldDeclaration2024 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20120 public static final BitSet FOLLOW_type_in_fieldDeclaration2034 = new BitSet(new long[]{0x0000000000000010L}); 20121 public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2044 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); 20122 public static final BitSet FOLLOW_COMMA_in_fieldDeclaration2055 = new BitSet(new long[]{0x0000000000000010L}); 20123 public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); 20124 public static final BitSet FOLLOW_SEMI_in_fieldDeclaration2078 = new BitSet(new long[]{0x0000000000000002L}); 20125 public static final BitSet FOLLOW_IDENTIFIER_in_variableDeclarator2097 = new BitSet(new long[]{0x0000000000000002L,0x0000000001040000L}); 20126 public static final BitSet FOLLOW_LBRACKET_in_variableDeclarator2108 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20127 public static final BitSet FOLLOW_RBRACKET_in_variableDeclarator2110 = new BitSet(new long[]{0x0000000000000002L,0x0000000001040000L}); 20128 public static final BitSet FOLLOW_EQ_in_variableDeclarator2132 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06014849L}); 20129 public static final BitSet FOLLOW_variableInitializer_in_variableDeclarator2134 = new BitSet(new long[]{0x0000000000000002L}); 20130 public static final BitSet FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172 = new BitSet(new long[]{0x0000000000000002L}); 20131 public static final BitSet FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182 = new BitSet(new long[]{0x0000000000000002L}); 20132 public static final BitSet FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192 = new BitSet(new long[]{0x0000000000000002L}); 20133 public static final BitSet FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202 = new BitSet(new long[]{0x0000000000000002L}); 20134 public static final BitSet FOLLOW_SEMI_in_interfaceBodyDeclaration2212 = new BitSet(new long[]{0x0000000000000002L}); 20135 public static final BitSet FOLLOW_modifiers_in_interfaceMethodDeclaration2231 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L}); 20136 public static final BitSet FOLLOW_typeParameters_in_interfaceMethodDeclaration2242 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L}); 20137 public static final BitSet FOLLOW_type_in_interfaceMethodDeclaration2264 = new BitSet(new long[]{0x0000000000000010L}); 20138 public static final BitSet FOLLOW_VOID_in_interfaceMethodDeclaration2275 = new BitSet(new long[]{0x0000000000000010L}); 20139 public static final BitSet FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20140 public static final BitSet FOLLOW_formalParameters_in_interfaceMethodDeclaration2305 = new BitSet(new long[]{0x0000000000000000L,0x0000000000140100L}); 20141 public static final BitSet FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20142 public static final BitSet FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318 = new BitSet(new long[]{0x0000000000000000L,0x0000000000140100L}); 20143 public static final BitSet FOLLOW_THROWS_in_interfaceMethodDeclaration2340 = new BitSet(new long[]{0x0000000000000010L}); 20144 public static final BitSet FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20145 public static final BitSet FOLLOW_SEMI_in_interfaceMethodDeclaration2355 = new BitSet(new long[]{0x0000000000000002L}); 20146 public static final BitSet FOLLOW_modifiers_in_interfaceFieldDeclaration2376 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20147 public static final BitSet FOLLOW_type_in_interfaceFieldDeclaration2378 = new BitSet(new long[]{0x0000000000000010L}); 20148 public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); 20149 public static final BitSet FOLLOW_COMMA_in_interfaceFieldDeclaration2391 = new BitSet(new long[]{0x0000000000000010L}); 20150 public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L}); 20151 public static final BitSet FOLLOW_SEMI_in_interfaceFieldDeclaration2414 = new BitSet(new long[]{0x0000000000000002L}); 20152 public static final BitSet FOLLOW_classOrInterfaceType_in_type2434 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20153 public static final BitSet FOLLOW_LBRACKET_in_type2445 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20154 public static final BitSet FOLLOW_RBRACKET_in_type2447 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20155 public static final BitSet FOLLOW_primitiveType_in_type2468 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20156 public static final BitSet FOLLOW_LBRACKET_in_type2479 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20157 public static final BitSet FOLLOW_RBRACKET_in_type2481 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20158 public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType2512 = new BitSet(new long[]{0x0000000000000002L,0x0020000000400000L}); 20159 public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType2523 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); 20160 public static final BitSet FOLLOW_DOT_in_classOrInterfaceType2545 = new BitSet(new long[]{0x0000000000000010L}); 20161 public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType2547 = new BitSet(new long[]{0x0000000000000002L,0x0020000000400000L}); 20162 public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType2562 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); 20163 public static final BitSet FOLLOW_set_in_primitiveType0 = new BitSet(new long[]{0x0000000000000002L}); 20164 public static final BitSet FOLLOW_LT_in_typeArguments2696 = new BitSet(new long[]{0x0140820940000010L,0x0000000008000001L}); 20165 public static final BitSet FOLLOW_typeArgument_in_typeArguments2698 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); 20166 public static final BitSet FOLLOW_COMMA_in_typeArguments2709 = new BitSet(new long[]{0x0140820940000010L,0x0000000008000001L}); 20167 public static final BitSet FOLLOW_typeArgument_in_typeArguments2711 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L}); 20168 public static final BitSet FOLLOW_GT_in_typeArguments2732 = new BitSet(new long[]{0x0000000000000002L}); 20169 public static final BitSet FOLLOW_type_in_typeArgument2751 = new BitSet(new long[]{0x0000000000000002L}); 20170 public static final BitSet FOLLOW_QUES_in_typeArgument2761 = new BitSet(new long[]{0x0000100000000002L,0x0000000000000008L}); 20171 public static final BitSet FOLLOW_set_in_typeArgument2785 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20172 public static final BitSet FOLLOW_type_in_typeArgument2829 = new BitSet(new long[]{0x0000000000000002L}); 20173 public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList2859 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20174 public static final BitSet FOLLOW_COMMA_in_qualifiedNameList2870 = new BitSet(new long[]{0x0000000000000010L}); 20175 public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList2872 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20176 public static final BitSet FOLLOW_LPAREN_in_formalParameters2902 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000008001L}); 20177 public static final BitSet FOLLOW_formalParameterDecls_in_formalParameters2913 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20178 public static final BitSet FOLLOW_RPAREN_in_formalParameters2934 = new BitSet(new long[]{0x0000000000000002L}); 20179 public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953 = new BitSet(new long[]{0x0000000000000002L}); 20180 public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2963 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20181 public static final BitSet FOLLOW_COMMA_in_formalParameterDecls2974 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); 20182 public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2976 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20183 public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); 20184 public static final BitSet FOLLOW_COMMA_in_formalParameterDecls3008 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); 20185 public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029 = new BitSet(new long[]{0x0000000000000002L}); 20186 public static final BitSet FOLLOW_variableModifiers_in_normalParameterDecl3048 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20187 public static final BitSet FOLLOW_type_in_normalParameterDecl3050 = new BitSet(new long[]{0x0000000000000010L}); 20188 public static final BitSet FOLLOW_IDENTIFIER_in_normalParameterDecl3052 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20189 public static final BitSet FOLLOW_LBRACKET_in_normalParameterDecl3063 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20190 public static final BitSet FOLLOW_RBRACKET_in_normalParameterDecl3065 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20191 public static final BitSet FOLLOW_variableModifiers_in_ellipsisParameterDecl3095 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20192 public static final BitSet FOLLOW_type_in_ellipsisParameterDecl3105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); 20193 public static final BitSet FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108 = new BitSet(new long[]{0x0000000000000010L}); 20194 public static final BitSet FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118 = new BitSet(new long[]{0x0000000000000002L}); 20195 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000048L}); 20196 public static final BitSet FOLLOW_set_in_explicitConstructorInvocation3165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20197 public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20198 public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3199 = new BitSet(new long[]{0x0000000000000002L}); 20199 public static final BitSet FOLLOW_primary_in_explicitConstructorInvocation3210 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); 20200 public static final BitSet FOLLOW_DOT_in_explicitConstructorInvocation3220 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000008L}); 20201 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); 20202 public static final BitSet FOLLOW_SUPER_in_explicitConstructorInvocation3252 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20203 public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20204 public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3264 = new BitSet(new long[]{0x0000000000000002L}); 20205 public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3283 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); 20206 public static final BitSet FOLLOW_DOT_in_qualifiedName3294 = new BitSet(new long[]{0x0000000000000010L}); 20207 public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3296 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); 20208 public static final BitSet FOLLOW_annotation_in_annotations3327 = new BitSet(new long[]{0x0000000000000002L,0x0004000000000000L}); 20209 public static final BitSet FOLLOW_MONKEYS_AT_in_annotation3359 = new BitSet(new long[]{0x0000000000000010L}); 20210 public static final BitSet FOLLOW_qualifiedName_in_annotation3361 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); 20211 public static final BitSet FOLLOW_LPAREN_in_annotation3375 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F0601C849L}); 20212 public static final BitSet FOLLOW_elementValuePairs_in_annotation3399 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20213 public static final BitSet FOLLOW_elementValue_in_annotation3423 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20214 public static final BitSet FOLLOW_RPAREN_in_annotation3458 = new BitSet(new long[]{0x0000000000000002L}); 20215 public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs3488 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20216 public static final BitSet FOLLOW_COMMA_in_elementValuePairs3499 = new BitSet(new long[]{0x0000000000000010L}); 20217 public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs3501 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20218 public static final BitSet FOLLOW_IDENTIFIER_in_elementValuePair3531 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); 20219 public static final BitSet FOLLOW_EQ_in_elementValuePair3533 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L}); 20220 public static final BitSet FOLLOW_elementValue_in_elementValuePair3535 = new BitSet(new long[]{0x0000000000000002L}); 20221 public static final BitSet FOLLOW_conditionalExpression_in_elementValue3554 = new BitSet(new long[]{0x0000000000000002L}); 20222 public static final BitSet FOLLOW_annotation_in_elementValue3564 = new BitSet(new long[]{0x0000000000000002L}); 20223 public static final BitSet FOLLOW_elementValueArrayInitializer_in_elementValue3574 = new BitSet(new long[]{0x0000000000000002L}); 20224 public static final BitSet FOLLOW_LBRACE_in_elementValueArrayInitializer3593 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06234849L}); 20225 public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer3604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); 20226 public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer3619 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L}); 20227 public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer3621 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); 20228 public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer3650 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); 20229 public static final BitSet FOLLOW_RBRACE_in_elementValueArrayInitializer3654 = new BitSet(new long[]{0x0000000000000002L}); 20230 public static final BitSet FOLLOW_modifiers_in_annotationTypeDeclaration3676 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); 20231 public static final BitSet FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678 = new BitSet(new long[]{0x0080000000000000L}); 20232 public static final BitSet FOLLOW_INTERFACE_in_annotationTypeDeclaration3688 = new BitSet(new long[]{0x0000000000000010L}); 20233 public static final BitSet FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); 20234 public static final BitSet FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708 = new BitSet(new long[]{0x0000000000000002L}); 20235 public static final BitSet FOLLOW_LBRACE_in_annotationTypeBody3728 = new BitSet(new long[]{0x73C0AA1950000010L,0x0004000000121227L}); 20236 public static final BitSet FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739 = new BitSet(new long[]{0x73C0AA1950000010L,0x0004000000121227L}); 20237 public static final BitSet FOLLOW_RBRACE_in_annotationTypeBody3760 = new BitSet(new long[]{0x0000000000000002L}); 20238 public static final BitSet FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781 = new BitSet(new long[]{0x0000000000000002L}); 20239 public static final BitSet FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791 = new BitSet(new long[]{0x0000000000000002L}); 20240 public static final BitSet FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801 = new BitSet(new long[]{0x0000000000000002L}); 20241 public static final BitSet FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811 = new BitSet(new long[]{0x0000000000000002L}); 20242 public static final BitSet FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821 = new BitSet(new long[]{0x0000000000000002L}); 20243 public static final BitSet FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831 = new BitSet(new long[]{0x0000000000000002L}); 20244 public static final BitSet FOLLOW_SEMI_in_annotationTypeElementDeclaration3841 = new BitSet(new long[]{0x0000000000000002L}); 20245 public static final BitSet FOLLOW_modifiers_in_annotationMethodDeclaration3860 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20246 public static final BitSet FOLLOW_type_in_annotationMethodDeclaration3862 = new BitSet(new long[]{0x0000000000000010L}); 20247 public static final BitSet FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20248 public static final BitSet FOLLOW_LPAREN_in_annotationMethodDeclaration3874 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20249 public static final BitSet FOLLOW_RPAREN_in_annotationMethodDeclaration3876 = new BitSet(new long[]{0x0000008000000000L,0x0000000000100000L}); 20250 public static final BitSet FOLLOW_DEFAULT_in_annotationMethodDeclaration3879 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L}); 20251 public static final BitSet FOLLOW_elementValue_in_annotationMethodDeclaration3881 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20252 public static final BitSet FOLLOW_SEMI_in_annotationMethodDeclaration3910 = new BitSet(new long[]{0x0000000000000002L}); 20253 public static final BitSet FOLLOW_LBRACE_in_block3933 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20254 public static final BitSet FOLLOW_blockStatement_in_block3944 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20255 public static final BitSet FOLLOW_RBRACE_in_block3965 = new BitSet(new long[]{0x0000000000000002L}); 20256 public static final BitSet FOLLOW_localVariableDeclarationStatement_in_blockStatement3986 = new BitSet(new long[]{0x0000000000000002L}); 20257 public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996 = new BitSet(new long[]{0x0000000000000002L}); 20258 public static final BitSet FOLLOW_statement_in_blockStatement4006 = new BitSet(new long[]{0x0000000000000002L}); 20259 public static final BitSet FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20260 public static final BitSet FOLLOW_SEMI_in_localVariableDeclarationStatement4036 = new BitSet(new long[]{0x0000000000000002L}); 20261 public static final BitSet FOLLOW_variableModifiers_in_localVariableDeclaration4055 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20262 public static final BitSet FOLLOW_type_in_localVariableDeclaration4057 = new BitSet(new long[]{0x0000000000000010L}); 20263 public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4067 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20264 public static final BitSet FOLLOW_COMMA_in_localVariableDeclaration4078 = new BitSet(new long[]{0x0000000000000010L}); 20265 public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4080 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20266 public static final BitSet FOLLOW_block_in_statement4110 = new BitSet(new long[]{0x0000000000000002L}); 20267 public static final BitSet FOLLOW_ASSERT_in_statement4122 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20268 public static final BitSet FOLLOW_expression_in_statement4142 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); 20269 public static final BitSet FOLLOW_COLON_in_statement4145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20270 public static final BitSet FOLLOW_expression_in_statement4147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20271 public static final BitSet FOLLOW_SEMI_in_statement4151 = new BitSet(new long[]{0x0000000000000002L}); 20272 public static final BitSet FOLLOW_ASSERT_in_statement4161 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20273 public static final BitSet FOLLOW_expression_in_statement4164 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); 20274 public static final BitSet FOLLOW_COLON_in_statement4167 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20275 public static final BitSet FOLLOW_expression_in_statement4169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20276 public static final BitSet FOLLOW_SEMI_in_statement4173 = new BitSet(new long[]{0x0000000000000002L}); 20277 public static final BitSet FOLLOW_IF_in_statement4183 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20278 public static final BitSet FOLLOW_parExpression_in_statement4185 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20279 public static final BitSet FOLLOW_statement_in_statement4187 = new BitSet(new long[]{0x0000040000000002L}); 20280 public static final BitSet FOLLOW_ELSE_in_statement4190 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20281 public static final BitSet FOLLOW_statement_in_statement4192 = new BitSet(new long[]{0x0000000000000002L}); 20282 public static final BitSet FOLLOW_forstatement_in_statement4204 = new BitSet(new long[]{0x0000000000000002L}); 20283 public static final BitSet FOLLOW_WHILE_in_statement4214 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20284 public static final BitSet FOLLOW_parExpression_in_statement4216 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20285 public static final BitSet FOLLOW_statement_in_statement4218 = new BitSet(new long[]{0x0000000000000002L}); 20286 public static final BitSet FOLLOW_DO_in_statement4228 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20287 public static final BitSet FOLLOW_statement_in_statement4230 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); 20288 public static final BitSet FOLLOW_WHILE_in_statement4232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20289 public static final BitSet FOLLOW_parExpression_in_statement4234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20290 public static final BitSet FOLLOW_SEMI_in_statement4236 = new BitSet(new long[]{0x0000000000000002L}); 20291 public static final BitSet FOLLOW_trystatement_in_statement4246 = new BitSet(new long[]{0x0000000000000002L}); 20292 public static final BitSet FOLLOW_SWITCH_in_statement4256 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20293 public static final BitSet FOLLOW_parExpression_in_statement4258 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); 20294 public static final BitSet FOLLOW_LBRACE_in_statement4260 = new BitSet(new long[]{0x0000008200000000L,0x0000000000020000L}); 20295 public static final BitSet FOLLOW_switchBlockStatementGroups_in_statement4262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); 20296 public static final BitSet FOLLOW_RBRACE_in_statement4264 = new BitSet(new long[]{0x0000000000000002L}); 20297 public static final BitSet FOLLOW_SYNCHRONIZED_in_statement4274 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20298 public static final BitSet FOLLOW_parExpression_in_statement4276 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20299 public static final BitSet FOLLOW_block_in_statement4278 = new BitSet(new long[]{0x0000000000000002L}); 20300 public static final BitSet FOLLOW_RETURN_in_statement4288 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06104849L}); 20301 public static final BitSet FOLLOW_expression_in_statement4291 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20302 public static final BitSet FOLLOW_SEMI_in_statement4296 = new BitSet(new long[]{0x0000000000000002L}); 20303 public static final BitSet FOLLOW_THROW_in_statement4306 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20304 public static final BitSet FOLLOW_expression_in_statement4308 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20305 public static final BitSet FOLLOW_SEMI_in_statement4310 = new BitSet(new long[]{0x0000000000000002L}); 20306 public static final BitSet FOLLOW_BREAK_in_statement4320 = new BitSet(new long[]{0x0000000000000010L,0x0000000000100000L}); 20307 public static final BitSet FOLLOW_IDENTIFIER_in_statement4335 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20308 public static final BitSet FOLLOW_SEMI_in_statement4352 = new BitSet(new long[]{0x0000000000000002L}); 20309 public static final BitSet FOLLOW_CONTINUE_in_statement4362 = new BitSet(new long[]{0x0000000000000010L,0x0000000000100000L}); 20310 public static final BitSet FOLLOW_IDENTIFIER_in_statement4377 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20311 public static final BitSet FOLLOW_SEMI_in_statement4394 = new BitSet(new long[]{0x0000000000000002L}); 20312 public static final BitSet FOLLOW_expression_in_statement4404 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20313 public static final BitSet FOLLOW_SEMI_in_statement4407 = new BitSet(new long[]{0x0000000000000002L}); 20314 public static final BitSet FOLLOW_IDENTIFIER_in_statement4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20315 public static final BitSet FOLLOW_COLON_in_statement4419 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20316 public static final BitSet FOLLOW_statement_in_statement4421 = new BitSet(new long[]{0x0000000000000002L}); 20317 public static final BitSet FOLLOW_SEMI_in_statement4431 = new BitSet(new long[]{0x0000000000000002L}); 20318 public static final BitSet FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452 = new BitSet(new long[]{0x0000008200000002L}); 20319 public static final BitSet FOLLOW_switchLabel_in_switchBlockStatementGroup4480 = new BitSet(new long[]{0xF7C5AB59F0003FF2L,0x0024000F06117EFFL}); 20320 public static final BitSet FOLLOW_blockStatement_in_switchBlockStatementGroup4491 = new BitSet(new long[]{0xF7C5AB59F0003FF2L,0x0024000F06117EFFL}); 20321 public static final BitSet FOLLOW_CASE_in_switchLabel4521 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20322 public static final BitSet FOLLOW_expression_in_switchLabel4523 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20323 public static final BitSet FOLLOW_COLON_in_switchLabel4525 = new BitSet(new long[]{0x0000000000000002L}); 20324 public static final BitSet FOLLOW_DEFAULT_in_switchLabel4535 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20325 public static final BitSet FOLLOW_COLON_in_switchLabel4537 = new BitSet(new long[]{0x0000000000000002L}); 20326 public static final BitSet FOLLOW_TRY_in_trystatement4557 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20327 public static final BitSet FOLLOW_block_in_trystatement4559 = new BitSet(new long[]{0x0000400400000000L}); 20328 public static final BitSet FOLLOW_catches_in_trystatement4573 = new BitSet(new long[]{0x0000400000000000L}); 20329 public static final BitSet FOLLOW_FINALLY_in_trystatement4575 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20330 public static final BitSet FOLLOW_block_in_trystatement4577 = new BitSet(new long[]{0x0000000000000002L}); 20331 public static final BitSet FOLLOW_catches_in_trystatement4591 = new BitSet(new long[]{0x0000000000000002L}); 20332 public static final BitSet FOLLOW_FINALLY_in_trystatement4605 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20333 public static final BitSet FOLLOW_block_in_trystatement4607 = new BitSet(new long[]{0x0000000000000002L}); 20334 public static final BitSet FOLLOW_catchClause_in_catches4637 = new BitSet(new long[]{0x0000000400000002L}); 20335 public static final BitSet FOLLOW_catchClause_in_catches4648 = new BitSet(new long[]{0x0000000400000002L}); 20336 public static final BitSet FOLLOW_CATCH_in_catchClause4678 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20337 public static final BitSet FOLLOW_LPAREN_in_catchClause4680 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); 20338 public static final BitSet FOLLOW_formalParameter_in_catchClause4682 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20339 public static final BitSet FOLLOW_RPAREN_in_catchClause4692 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20340 public static final BitSet FOLLOW_block_in_catchClause4694 = new BitSet(new long[]{0x0000000000000002L}); 20341 public static final BitSet FOLLOW_variableModifiers_in_formalParameter4713 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20342 public static final BitSet FOLLOW_type_in_formalParameter4715 = new BitSet(new long[]{0x0000000000000010L}); 20343 public static final BitSet FOLLOW_IDENTIFIER_in_formalParameter4717 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20344 public static final BitSet FOLLOW_LBRACKET_in_formalParameter4728 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20345 public static final BitSet FOLLOW_RBRACKET_in_formalParameter4730 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20346 public static final BitSet FOLLOW_FOR_in_forstatement4775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20347 public static final BitSet FOLLOW_LPAREN_in_forstatement4777 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); 20348 public static final BitSet FOLLOW_variableModifiers_in_forstatement4779 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20349 public static final BitSet FOLLOW_type_in_forstatement4781 = new BitSet(new long[]{0x0000000000000010L}); 20350 public static final BitSet FOLLOW_IDENTIFIER_in_forstatement4783 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20351 public static final BitSet FOLLOW_COLON_in_forstatement4785 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20352 public static final BitSet FOLLOW_expression_in_forstatement4795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20353 public static final BitSet FOLLOW_RPAREN_in_forstatement4797 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20354 public static final BitSet FOLLOW_statement_in_forstatement4799 = new BitSet(new long[]{0x0000000000000002L}); 20355 public static final BitSet FOLLOW_FOR_in_forstatement4819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20356 public static final BitSet FOLLOW_LPAREN_in_forstatement4821 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F06104849L}); 20357 public static final BitSet FOLLOW_forInit_in_forstatement4840 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20358 public static final BitSet FOLLOW_SEMI_in_forstatement4861 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06104849L}); 20359 public static final BitSet FOLLOW_expression_in_forstatement4880 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20360 public static final BitSet FOLLOW_SEMI_in_forstatement4901 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F0600C849L}); 20361 public static final BitSet FOLLOW_expressionList_in_forstatement4920 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20362 public static final BitSet FOLLOW_RPAREN_in_forstatement4941 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20363 public static final BitSet FOLLOW_statement_in_forstatement4943 = new BitSet(new long[]{0x0000000000000002L}); 20364 public static final BitSet FOLLOW_localVariableDeclaration_in_forInit4962 = new BitSet(new long[]{0x0000000000000002L}); 20365 public static final BitSet FOLLOW_expressionList_in_forInit4972 = new BitSet(new long[]{0x0000000000000002L}); 20366 public static final BitSet FOLLOW_LPAREN_in_parExpression4991 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20367 public static final BitSet FOLLOW_expression_in_parExpression4993 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20368 public static final BitSet FOLLOW_RPAREN_in_parExpression4995 = new BitSet(new long[]{0x0000000000000002L}); 20369 public static final BitSet FOLLOW_expression_in_expressionList5014 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20370 public static final BitSet FOLLOW_COMMA_in_expressionList5025 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20371 public static final BitSet FOLLOW_expression_in_expressionList5027 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20372 public static final BitSet FOLLOW_conditionalExpression_in_expression5058 = new BitSet(new long[]{0x0000000000000002L,0x0033FC0001000000L}); 20373 public static final BitSet FOLLOW_assignmentOperator_in_expression5069 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20374 public static final BitSet FOLLOW_expression_in_expression5071 = new BitSet(new long[]{0x0000000000000002L}); 20375 public static final BitSet FOLLOW_EQ_in_assignmentOperator5102 = new BitSet(new long[]{0x0000000000000002L}); 20376 public static final BitSet FOLLOW_PLUSEQ_in_assignmentOperator5112 = new BitSet(new long[]{0x0000000000000002L}); 20377 public static final BitSet FOLLOW_SUBEQ_in_assignmentOperator5122 = new BitSet(new long[]{0x0000000000000002L}); 20378 public static final BitSet FOLLOW_STAREQ_in_assignmentOperator5132 = new BitSet(new long[]{0x0000000000000002L}); 20379 public static final BitSet FOLLOW_SLASHEQ_in_assignmentOperator5142 = new BitSet(new long[]{0x0000000000000002L}); 20380 public static final BitSet FOLLOW_AMPEQ_in_assignmentOperator5152 = new BitSet(new long[]{0x0000000000000002L}); 20381 public static final BitSet FOLLOW_BAREQ_in_assignmentOperator5162 = new BitSet(new long[]{0x0000000000000002L}); 20382 public static final BitSet FOLLOW_CARETEQ_in_assignmentOperator5172 = new BitSet(new long[]{0x0000000000000002L}); 20383 public static final BitSet FOLLOW_PERCENTEQ_in_assignmentOperator5182 = new BitSet(new long[]{0x0000000000000002L}); 20384 public static final BitSet FOLLOW_LT_in_assignmentOperator5193 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); 20385 public static final BitSet FOLLOW_LT_in_assignmentOperator5195 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); 20386 public static final BitSet FOLLOW_EQ_in_assignmentOperator5197 = new BitSet(new long[]{0x0000000000000002L}); 20387 public static final BitSet FOLLOW_GT_in_assignmentOperator5208 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20388 public static final BitSet FOLLOW_GT_in_assignmentOperator5210 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20389 public static final BitSet FOLLOW_GT_in_assignmentOperator5212 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); 20390 public static final BitSet FOLLOW_EQ_in_assignmentOperator5214 = new BitSet(new long[]{0x0000000000000002L}); 20391 public static final BitSet FOLLOW_GT_in_assignmentOperator5225 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20392 public static final BitSet FOLLOW_GT_in_assignmentOperator5227 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); 20393 public static final BitSet FOLLOW_EQ_in_assignmentOperator5229 = new BitSet(new long[]{0x0000000000000002L}); 20394 public static final BitSet FOLLOW_conditionalOrExpression_in_conditionalExpression5249 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L}); 20395 public static final BitSet FOLLOW_QUES_in_conditionalExpression5260 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20396 public static final BitSet FOLLOW_expression_in_conditionalExpression5262 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20397 public static final BitSet FOLLOW_COLON_in_conditionalExpression5264 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20398 public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression5266 = new BitSet(new long[]{0x0000000000000002L}); 20399 public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296 = new BitSet(new long[]{0x0000000000000002L,0x0000000080000000L}); 20400 public static final BitSet FOLLOW_BARBAR_in_conditionalOrExpression5307 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20401 public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309 = new BitSet(new long[]{0x0000000000000002L,0x0000000080000000L}); 20402 public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L}); 20403 public static final BitSet FOLLOW_AMPAMP_in_conditionalAndExpression5350 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20404 public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L}); 20405 public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L}); 20406 public static final BitSet FOLLOW_BAR_in_inclusiveOrExpression5393 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20407 public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L}); 20408 public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression5425 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L}); 20409 public static final BitSet FOLLOW_CARET_in_exclusiveOrExpression5436 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20410 public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression5438 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L}); 20411 public static final BitSet FOLLOW_equalityExpression_in_andExpression5468 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); 20412 public static final BitSet FOLLOW_AMP_in_andExpression5479 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20413 public static final BitSet FOLLOW_equalityExpression_in_andExpression5481 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L}); 20414 public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression5511 = new BitSet(new long[]{0x0000000000000002L,0x0008000020000000L}); 20415 public static final BitSet FOLLOW_set_in_equalityExpression5535 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20416 public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression5585 = new BitSet(new long[]{0x0000000000000002L,0x0008000020000000L}); 20417 public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression5615 = new BitSet(new long[]{0x0020000000000002L}); 20418 public static final BitSet FOLLOW_INSTANCEOF_in_instanceOfExpression5626 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20419 public static final BitSet FOLLOW_type_in_instanceOfExpression5628 = new BitSet(new long[]{0x0000000000000002L}); 20420 public static final BitSet FOLLOW_shiftExpression_in_relationalExpression5658 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); 20421 public static final BitSet FOLLOW_relationalOp_in_relationalExpression5669 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20422 public static final BitSet FOLLOW_shiftExpression_in_relationalExpression5671 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); 20423 public static final BitSet FOLLOW_LT_in_relationalOp5702 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); 20424 public static final BitSet FOLLOW_EQ_in_relationalOp5704 = new BitSet(new long[]{0x0000000000000002L}); 20425 public static final BitSet FOLLOW_GT_in_relationalOp5715 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); 20426 public static final BitSet FOLLOW_EQ_in_relationalOp5717 = new BitSet(new long[]{0x0000000000000002L}); 20427 public static final BitSet FOLLOW_LT_in_relationalOp5727 = new BitSet(new long[]{0x0000000000000002L}); 20428 public static final BitSet FOLLOW_GT_in_relationalOp5737 = new BitSet(new long[]{0x0000000000000002L}); 20429 public static final BitSet FOLLOW_additiveExpression_in_shiftExpression5756 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); 20430 public static final BitSet FOLLOW_shiftOp_in_shiftExpression5767 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20431 public static final BitSet FOLLOW_additiveExpression_in_shiftExpression5769 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L}); 20432 public static final BitSet FOLLOW_LT_in_shiftOp5801 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); 20433 public static final BitSet FOLLOW_LT_in_shiftOp5803 = new BitSet(new long[]{0x0000000000000002L}); 20434 public static final BitSet FOLLOW_GT_in_shiftOp5814 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20435 public static final BitSet FOLLOW_GT_in_shiftOp5816 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20436 public static final BitSet FOLLOW_GT_in_shiftOp5818 = new BitSet(new long[]{0x0000000000000002L}); 20437 public static final BitSet FOLLOW_GT_in_shiftOp5829 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20438 public static final BitSet FOLLOW_GT_in_shiftOp5831 = new BitSet(new long[]{0x0000000000000002L}); 20439 public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression5851 = new BitSet(new long[]{0x0000000000000002L,0x0000000C00000000L}); 20440 public static final BitSet FOLLOW_set_in_additiveExpression5875 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20441 public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression5925 = new BitSet(new long[]{0x0000000000000002L,0x0000000C00000000L}); 20442 public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5962 = new BitSet(new long[]{0x0000000000000002L,0x0000023000000000L}); 20443 public static final BitSet FOLLOW_set_in_multiplicativeExpression5986 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20444 public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression6054 = new BitSet(new long[]{0x0000000000000002L,0x0000023000000000L}); 20445 public static final BitSet FOLLOW_PLUS_in_unaryExpression6086 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20446 public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6089 = new BitSet(new long[]{0x0000000000000002L}); 20447 public static final BitSet FOLLOW_SUB_in_unaryExpression6099 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20448 public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6101 = new BitSet(new long[]{0x0000000000000002L}); 20449 public static final BitSet FOLLOW_PLUSPLUS_in_unaryExpression6111 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20450 public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6113 = new BitSet(new long[]{0x0000000000000002L}); 20451 public static final BitSet FOLLOW_SUBSUB_in_unaryExpression6123 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20452 public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6125 = new BitSet(new long[]{0x0000000000000002L}); 20453 public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135 = new BitSet(new long[]{0x0000000000000002L}); 20454 public static final BitSet FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20455 public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156 = new BitSet(new long[]{0x0000000000000002L}); 20456 public static final BitSet FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20457 public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168 = new BitSet(new long[]{0x0000000000000002L}); 20458 public static final BitSet FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178 = new BitSet(new long[]{0x0000000000000002L}); 20459 public static final BitSet FOLLOW_primary_in_unaryExpressionNotPlusMinus6188 = new BitSet(new long[]{0x0000000000000002L,0x0000000300440000L}); 20460 public static final BitSet FOLLOW_selector_in_unaryExpressionNotPlusMinus6199 = new BitSet(new long[]{0x0000000000000002L,0x0000000300440000L}); 20461 public static final BitSet FOLLOW_set_in_unaryExpressionNotPlusMinus6220 = new BitSet(new long[]{0x0000000000000002L}); 20462 public static final BitSet FOLLOW_LPAREN_in_castExpression6268 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20463 public static final BitSet FOLLOW_primitiveType_in_castExpression6270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20464 public static final BitSet FOLLOW_RPAREN_in_castExpression6272 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20465 public static final BitSet FOLLOW_unaryExpression_in_castExpression6274 = new BitSet(new long[]{0x0000000000000002L}); 20466 public static final BitSet FOLLOW_LPAREN_in_castExpression6284 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20467 public static final BitSet FOLLOW_type_in_castExpression6286 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20468 public static final BitSet FOLLOW_RPAREN_in_castExpression6288 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20469 public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290 = new BitSet(new long[]{0x0000000000000002L}); 20470 public static final BitSet FOLLOW_parExpression_in_primary6311 = new BitSet(new long[]{0x0000000000000002L}); 20471 public static final BitSet FOLLOW_THIS_in_primary6321 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); 20472 public static final BitSet FOLLOW_DOT_in_primary6332 = new BitSet(new long[]{0x0000000000000010L}); 20473 public static final BitSet FOLLOW_IDENTIFIER_in_primary6334 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); 20474 public static final BitSet FOLLOW_identifierSuffix_in_primary6356 = new BitSet(new long[]{0x0000000000000002L}); 20475 public static final BitSet FOLLOW_IDENTIFIER_in_primary6377 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); 20476 public static final BitSet FOLLOW_DOT_in_primary6388 = new BitSet(new long[]{0x0000000000000010L}); 20477 public static final BitSet FOLLOW_IDENTIFIER_in_primary6390 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L}); 20478 public static final BitSet FOLLOW_identifierSuffix_in_primary6412 = new BitSet(new long[]{0x0000000000000002L}); 20479 public static final BitSet FOLLOW_SUPER_in_primary6433 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L}); 20480 public static final BitSet FOLLOW_superSuffix_in_primary6443 = new BitSet(new long[]{0x0000000000000002L}); 20481 public static final BitSet FOLLOW_literal_in_primary6453 = new BitSet(new long[]{0x0000000000000002L}); 20482 public static final BitSet FOLLOW_creator_in_primary6463 = new BitSet(new long[]{0x0000000000000002L}); 20483 public static final BitSet FOLLOW_primitiveType_in_primary6473 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L}); 20484 public static final BitSet FOLLOW_LBRACKET_in_primary6484 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20485 public static final BitSet FOLLOW_RBRACKET_in_primary6486 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L}); 20486 public static final BitSet FOLLOW_DOT_in_primary6507 = new BitSet(new long[]{0x0000001000000000L}); 20487 public static final BitSet FOLLOW_CLASS_in_primary6509 = new BitSet(new long[]{0x0000000000000002L}); 20488 public static final BitSet FOLLOW_VOID_in_primary6519 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); 20489 public static final BitSet FOLLOW_DOT_in_primary6521 = new BitSet(new long[]{0x0000001000000000L}); 20490 public static final BitSet FOLLOW_CLASS_in_primary6523 = new BitSet(new long[]{0x0000000000000002L}); 20491 public static final BitSet FOLLOW_arguments_in_superSuffix6543 = new BitSet(new long[]{0x0000000000000002L}); 20492 public static final BitSet FOLLOW_DOT_in_superSuffix6553 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); 20493 public static final BitSet FOLLOW_typeArguments_in_superSuffix6556 = new BitSet(new long[]{0x0000000000000010L}); 20494 public static final BitSet FOLLOW_IDENTIFIER_in_superSuffix6577 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); 20495 public static final BitSet FOLLOW_arguments_in_superSuffix6588 = new BitSet(new long[]{0x0000000000000002L}); 20496 public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix6620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20497 public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix6622 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L}); 20498 public static final BitSet FOLLOW_DOT_in_identifierSuffix6643 = new BitSet(new long[]{0x0000001000000000L}); 20499 public static final BitSet FOLLOW_CLASS_in_identifierSuffix6645 = new BitSet(new long[]{0x0000000000000002L}); 20500 public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix6656 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20501 public static final BitSet FOLLOW_expression_in_identifierSuffix6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20502 public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix6660 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20503 public static final BitSet FOLLOW_arguments_in_identifierSuffix6681 = new BitSet(new long[]{0x0000000000000002L}); 20504 public static final BitSet FOLLOW_DOT_in_identifierSuffix6691 = new BitSet(new long[]{0x0000001000000000L}); 20505 public static final BitSet FOLLOW_CLASS_in_identifierSuffix6693 = new BitSet(new long[]{0x0000000000000002L}); 20506 public static final BitSet FOLLOW_DOT_in_identifierSuffix6703 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); 20507 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705 = new BitSet(new long[]{0x0000000000000010L}); 20508 public static final BitSet FOLLOW_IDENTIFIER_in_identifierSuffix6707 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20509 public static final BitSet FOLLOW_arguments_in_identifierSuffix6709 = new BitSet(new long[]{0x0000000000000002L}); 20510 public static final BitSet FOLLOW_DOT_in_identifierSuffix6719 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); 20511 public static final BitSet FOLLOW_THIS_in_identifierSuffix6721 = new BitSet(new long[]{0x0000000000000002L}); 20512 public static final BitSet FOLLOW_DOT_in_identifierSuffix6731 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); 20513 public static final BitSet FOLLOW_SUPER_in_identifierSuffix6733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20514 public static final BitSet FOLLOW_arguments_in_identifierSuffix6735 = new BitSet(new long[]{0x0000000000000002L}); 20515 public static final BitSet FOLLOW_innerCreator_in_identifierSuffix6745 = new BitSet(new long[]{0x0000000000000002L}); 20516 public static final BitSet FOLLOW_DOT_in_selector6765 = new BitSet(new long[]{0x0000000000000010L}); 20517 public static final BitSet FOLLOW_IDENTIFIER_in_selector6767 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); 20518 public static final BitSet FOLLOW_arguments_in_selector6778 = new BitSet(new long[]{0x0000000000000002L}); 20519 public static final BitSet FOLLOW_DOT_in_selector6799 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); 20520 public static final BitSet FOLLOW_THIS_in_selector6801 = new BitSet(new long[]{0x0000000000000002L}); 20521 public static final BitSet FOLLOW_DOT_in_selector6811 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); 20522 public static final BitSet FOLLOW_SUPER_in_selector6813 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L}); 20523 public static final BitSet FOLLOW_superSuffix_in_selector6823 = new BitSet(new long[]{0x0000000000000002L}); 20524 public static final BitSet FOLLOW_innerCreator_in_selector6833 = new BitSet(new long[]{0x0000000000000002L}); 20525 public static final BitSet FOLLOW_LBRACKET_in_selector6843 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20526 public static final BitSet FOLLOW_expression_in_selector6845 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20527 public static final BitSet FOLLOW_RBRACKET_in_selector6847 = new BitSet(new long[]{0x0000000000000002L}); 20528 public static final BitSet FOLLOW_NEW_in_creator6866 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); 20529 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_creator6868 = new BitSet(new long[]{0x0000000000000010L}); 20530 public static final BitSet FOLLOW_classOrInterfaceType_in_creator6870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20531 public static final BitSet FOLLOW_classCreatorRest_in_creator6872 = new BitSet(new long[]{0x0000000000000002L}); 20532 public static final BitSet FOLLOW_NEW_in_creator6882 = new BitSet(new long[]{0x0000000000000010L}); 20533 public static final BitSet FOLLOW_classOrInterfaceType_in_creator6884 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20534 public static final BitSet FOLLOW_classCreatorRest_in_creator6886 = new BitSet(new long[]{0x0000000000000002L}); 20535 public static final BitSet FOLLOW_arrayCreator_in_creator6896 = new BitSet(new long[]{0x0000000000000002L}); 20536 public static final BitSet FOLLOW_NEW_in_arrayCreator6915 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20537 public static final BitSet FOLLOW_createdName_in_arrayCreator6917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); 20538 public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6927 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20539 public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); 20540 public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20541 public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); 20542 public static final BitSet FOLLOW_arrayInitializer_in_arrayCreator6963 = new BitSet(new long[]{0x0000000000000002L}); 20543 public static final BitSet FOLLOW_NEW_in_arrayCreator6974 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20544 public static final BitSet FOLLOW_createdName_in_arrayCreator6976 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); 20545 public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6986 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20546 public static final BitSet FOLLOW_expression_in_arrayCreator6988 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20547 public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6998 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20548 public static final BitSet FOLLOW_LBRACKET_in_arrayCreator7012 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20549 public static final BitSet FOLLOW_expression_in_arrayCreator7014 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20550 public static final BitSet FOLLOW_RBRACKET_in_arrayCreator7028 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20551 public static final BitSet FOLLOW_LBRACKET_in_arrayCreator7050 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20552 public static final BitSet FOLLOW_RBRACKET_in_arrayCreator7052 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); 20553 public static final BitSet FOLLOW_arrayInitializer_in_variableInitializer7082 = new BitSet(new long[]{0x0000000000000002L}); 20554 public static final BitSet FOLLOW_expression_in_variableInitializer7092 = new BitSet(new long[]{0x0000000000000002L}); 20555 public static final BitSet FOLLOW_LBRACE_in_arrayInitializer7111 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06234849L}); 20556 public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer7126 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); 20557 public static final BitSet FOLLOW_COMMA_in_arrayInitializer7145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06014849L}); 20558 public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer7147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L}); 20559 public static final BitSet FOLLOW_COMMA_in_arrayInitializer7196 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); 20560 public static final BitSet FOLLOW_RBRACE_in_arrayInitializer7208 = new BitSet(new long[]{0x0000000000000002L}); 20561 public static final BitSet FOLLOW_classOrInterfaceType_in_createdName7241 = new BitSet(new long[]{0x0000000000000002L}); 20562 public static final BitSet FOLLOW_primitiveType_in_createdName7251 = new BitSet(new long[]{0x0000000000000002L}); 20563 public static final BitSet FOLLOW_DOT_in_innerCreator7270 = new BitSet(new long[]{0x0400000000000000L}); 20564 public static final BitSet FOLLOW_NEW_in_innerCreator7272 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); 20565 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_innerCreator7283 = new BitSet(new long[]{0x0000000000000010L}); 20566 public static final BitSet FOLLOW_IDENTIFIER_in_innerCreator7304 = new BitSet(new long[]{0x0000000000000000L,0x0020000000004000L}); 20567 public static final BitSet FOLLOW_typeArguments_in_innerCreator7315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20568 public static final BitSet FOLLOW_classCreatorRest_in_innerCreator7336 = new BitSet(new long[]{0x0000000000000002L}); 20569 public static final BitSet FOLLOW_arguments_in_classCreatorRest7356 = new BitSet(new long[]{0x0008100000000002L,0x0020000000010000L}); 20570 public static final BitSet FOLLOW_classBody_in_classCreatorRest7367 = new BitSet(new long[]{0x0000000000000002L}); 20571 public static final BitSet FOLLOW_LT_in_nonWildcardTypeArguments7398 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20572 public static final BitSet FOLLOW_typeList_in_nonWildcardTypeArguments7400 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); 20573 public static final BitSet FOLLOW_GT_in_nonWildcardTypeArguments7410 = new BitSet(new long[]{0x0000000000000002L}); 20574 public static final BitSet FOLLOW_LPAREN_in_arguments7429 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F0600C849L}); 20575 public static final BitSet FOLLOW_expressionList_in_arguments7432 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20576 public static final BitSet FOLLOW_RPAREN_in_arguments7445 = new BitSet(new long[]{0x0000000000000002L}); 20577 public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L}); 20578 public static final BitSet FOLLOW_modifiers_in_classHeader7566 = new BitSet(new long[]{0x0000001000000000L}); 20579 public static final BitSet FOLLOW_CLASS_in_classHeader7568 = new BitSet(new long[]{0x0000000000000010L}); 20580 public static final BitSet FOLLOW_IDENTIFIER_in_classHeader7570 = new BitSet(new long[]{0x0000000000000002L}); 20581 public static final BitSet FOLLOW_modifiers_in_enumHeader7589 = new BitSet(new long[]{0x0000080000000010L}); 20582 public static final BitSet FOLLOW_set_in_enumHeader7591 = new BitSet(new long[]{0x0000000000000010L}); 20583 public static final BitSet FOLLOW_IDENTIFIER_in_enumHeader7597 = new BitSet(new long[]{0x0000000000000002L}); 20584 public static final BitSet FOLLOW_modifiers_in_interfaceHeader7616 = new BitSet(new long[]{0x0080000000000000L}); 20585 public static final BitSet FOLLOW_INTERFACE_in_interfaceHeader7618 = new BitSet(new long[]{0x0000000000000010L}); 20586 public static final BitSet FOLLOW_IDENTIFIER_in_interfaceHeader7620 = new BitSet(new long[]{0x0000000000000002L}); 20587 public static final BitSet FOLLOW_modifiers_in_annotationHeader7639 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); 20588 public static final BitSet FOLLOW_MONKEYS_AT_in_annotationHeader7641 = new BitSet(new long[]{0x0080000000000000L}); 20589 public static final BitSet FOLLOW_INTERFACE_in_annotationHeader7643 = new BitSet(new long[]{0x0000000000000010L}); 20590 public static final BitSet FOLLOW_IDENTIFIER_in_annotationHeader7645 = new BitSet(new long[]{0x0000000000000002L}); 20591 public static final BitSet FOLLOW_modifiers_in_typeHeader7664 = new BitSet(new long[]{0x0080081000000000L,0x0004000000000000L}); 20592 public static final BitSet FOLLOW_CLASS_in_typeHeader7667 = new BitSet(new long[]{0x0000000000000010L}); 20593 public static final BitSet FOLLOW_ENUM_in_typeHeader7669 = new BitSet(new long[]{0x0000000000000010L}); 20594 public static final BitSet FOLLOW_MONKEYS_AT_in_typeHeader7672 = new BitSet(new long[]{0x0080000000000000L}); 20595 public static final BitSet FOLLOW_INTERFACE_in_typeHeader7676 = new BitSet(new long[]{0x0000000000000010L}); 20596 public static final BitSet FOLLOW_IDENTIFIER_in_typeHeader7680 = new BitSet(new long[]{0x0000000000000002L}); 20597 public static final BitSet FOLLOW_modifiers_in_methodHeader7699 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L}); 20598 public static final BitSet FOLLOW_typeParameters_in_methodHeader7701 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L}); 20599 public static final BitSet FOLLOW_type_in_methodHeader7705 = new BitSet(new long[]{0x0000000000000010L}); 20600 public static final BitSet FOLLOW_VOID_in_methodHeader7707 = new BitSet(new long[]{0x0000000000000010L}); 20601 public static final BitSet FOLLOW_IDENTIFIER_in_methodHeader7711 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20602 public static final BitSet FOLLOW_LPAREN_in_methodHeader7713 = new BitSet(new long[]{0x0000000000000002L}); 20603 public static final BitSet FOLLOW_modifiers_in_fieldHeader7732 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20604 public static final BitSet FOLLOW_type_in_fieldHeader7734 = new BitSet(new long[]{0x0000000000000010L}); 20605 public static final BitSet FOLLOW_IDENTIFIER_in_fieldHeader7736 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); 20606 public static final BitSet FOLLOW_LBRACKET_in_fieldHeader7739 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20607 public static final BitSet FOLLOW_RBRACKET_in_fieldHeader7740 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); 20608 public static final BitSet FOLLOW_set_in_fieldHeader7744 = new BitSet(new long[]{0x0000000000000002L}); 20609 public static final BitSet FOLLOW_variableModifiers_in_localVariableHeader7769 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20610 public static final BitSet FOLLOW_type_in_localVariableHeader7771 = new BitSet(new long[]{0x0000000000000010L}); 20611 public static final BitSet FOLLOW_IDENTIFIER_in_localVariableHeader7773 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); 20612 public static final BitSet FOLLOW_LBRACKET_in_localVariableHeader7776 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20613 public static final BitSet FOLLOW_RBRACKET_in_localVariableHeader7777 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L}); 20614 public static final BitSet FOLLOW_set_in_localVariableHeader7781 = new BitSet(new long[]{0x0000000000000002L}); 20615 public static final BitSet FOLLOW_annotations_in_synpred2_Java64 = new BitSet(new long[]{0x0800000000000000L}); 20616 public static final BitSet FOLLOW_packageDeclaration_in_synpred2_Java93 = new BitSet(new long[]{0x0000000000000002L}); 20617 public static final BitSet FOLLOW_classDeclaration_in_synpred12_Java436 = new BitSet(new long[]{0x0000000000000002L}); 20618 public static final BitSet FOLLOW_normalClassDeclaration_in_synpred27_Java659 = new BitSet(new long[]{0x0000000000000002L}); 20619 public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306 = new BitSet(new long[]{0x0000000000000002L}); 20620 public static final BitSet FOLLOW_fieldDeclaration_in_synpred52_Java1621 = new BitSet(new long[]{0x0000000000000002L}); 20621 public static final BitSet FOLLOW_methodDeclaration_in_synpred53_Java1632 = new BitSet(new long[]{0x0000000000000002L}); 20622 public static final BitSet FOLLOW_classDeclaration_in_synpred54_Java1643 = new BitSet(new long[]{0x0000000000000002L}); 20623 public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778 = new BitSet(new long[]{0x0000000000000002L}); 20624 public static final BitSet FOLLOW_modifiers_in_synpred59_Java1691 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L}); 20625 public static final BitSet FOLLOW_typeParameters_in_synpred59_Java1702 = new BitSet(new long[]{0x0000000000000010L}); 20626 public static final BitSet FOLLOW_IDENTIFIER_in_synpred59_Java1723 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20627 public static final BitSet FOLLOW_formalParameters_in_synpred59_Java1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010100L}); 20628 public static final BitSet FOLLOW_THROWS_in_synpred59_Java1744 = new BitSet(new long[]{0x0000000000000010L}); 20629 public static final BitSet FOLLOW_qualifiedNameList_in_synpred59_Java1746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); 20630 public static final BitSet FOLLOW_LBRACE_in_synpred59_Java1767 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20631 public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20632 public static final BitSet FOLLOW_blockStatement_in_synpred59_Java1800 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL}); 20633 public static final BitSet FOLLOW_RBRACE_in_synpred59_Java1821 = new BitSet(new long[]{0x0000000000000002L}); 20634 public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172 = new BitSet(new long[]{0x0000000000000002L}); 20635 public static final BitSet FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182 = new BitSet(new long[]{0x0000000000000002L}); 20636 public static final BitSet FOLLOW_interfaceDeclaration_in_synpred70_Java2192 = new BitSet(new long[]{0x0000000000000002L}); 20637 public static final BitSet FOLLOW_classDeclaration_in_synpred71_Java2202 = new BitSet(new long[]{0x0000000000000002L}); 20638 public static final BitSet FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953 = new BitSet(new long[]{0x0000000000000002L}); 20639 public static final BitSet FOLLOW_normalParameterDecl_in_synpred98_Java2963 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20640 public static final BitSet FOLLOW_COMMA_in_synpred98_Java2974 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); 20641 public static final BitSet FOLLOW_normalParameterDecl_in_synpred98_Java2976 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L}); 20642 public static final BitSet FOLLOW_normalParameterDecl_in_synpred99_Java2998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); 20643 public static final BitSet FOLLOW_COMMA_in_synpred99_Java3008 = new BitSet(new long[]{0x0000000000000002L}); 20644 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000048L}); 20645 public static final BitSet FOLLOW_set_in_synpred103_Java3165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20646 public static final BitSet FOLLOW_arguments_in_synpred103_Java3197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20647 public static final BitSet FOLLOW_SEMI_in_synpred103_Java3199 = new BitSet(new long[]{0x0000000000000002L}); 20648 public static final BitSet FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781 = new BitSet(new long[]{0x0000000000000002L}); 20649 public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791 = new BitSet(new long[]{0x0000000000000002L}); 20650 public static final BitSet FOLLOW_normalClassDeclaration_in_synpred119_Java3801 = new BitSet(new long[]{0x0000000000000002L}); 20651 public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811 = new BitSet(new long[]{0x0000000000000002L}); 20652 public static final BitSet FOLLOW_enumDeclaration_in_synpred121_Java3821 = new BitSet(new long[]{0x0000000000000002L}); 20653 public static final BitSet FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831 = new BitSet(new long[]{0x0000000000000002L}); 20654 public static final BitSet FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986 = new BitSet(new long[]{0x0000000000000002L}); 20655 public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996 = new BitSet(new long[]{0x0000000000000002L}); 20656 public static final BitSet FOLLOW_ASSERT_in_synpred130_Java4122 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20657 public static final BitSet FOLLOW_expression_in_synpred130_Java4142 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); 20658 public static final BitSet FOLLOW_COLON_in_synpred130_Java4145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20659 public static final BitSet FOLLOW_expression_in_synpred130_Java4147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20660 public static final BitSet FOLLOW_SEMI_in_synpred130_Java4151 = new BitSet(new long[]{0x0000000000000002L}); 20661 public static final BitSet FOLLOW_ASSERT_in_synpred132_Java4161 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20662 public static final BitSet FOLLOW_expression_in_synpred132_Java4164 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L}); 20663 public static final BitSet FOLLOW_COLON_in_synpred132_Java4167 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20664 public static final BitSet FOLLOW_expression_in_synpred132_Java4169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20665 public static final BitSet FOLLOW_SEMI_in_synpred132_Java4173 = new BitSet(new long[]{0x0000000000000002L}); 20666 public static final BitSet FOLLOW_ELSE_in_synpred133_Java4190 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20667 public static final BitSet FOLLOW_statement_in_synpred133_Java4192 = new BitSet(new long[]{0x0000000000000002L}); 20668 public static final BitSet FOLLOW_expression_in_synpred148_Java4404 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); 20669 public static final BitSet FOLLOW_SEMI_in_synpred148_Java4407 = new BitSet(new long[]{0x0000000000000002L}); 20670 public static final BitSet FOLLOW_IDENTIFIER_in_synpred149_Java4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20671 public static final BitSet FOLLOW_COLON_in_synpred149_Java4419 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20672 public static final BitSet FOLLOW_statement_in_synpred149_Java4421 = new BitSet(new long[]{0x0000000000000002L}); 20673 public static final BitSet FOLLOW_catches_in_synpred153_Java4573 = new BitSet(new long[]{0x0000400000000000L}); 20674 public static final BitSet FOLLOW_FINALLY_in_synpred153_Java4575 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L}); 20675 public static final BitSet FOLLOW_block_in_synpred153_Java4577 = new BitSet(new long[]{0x0000000000000002L}); 20676 public static final BitSet FOLLOW_catches_in_synpred154_Java4591 = new BitSet(new long[]{0x0000000000000002L}); 20677 public static final BitSet FOLLOW_FOR_in_synpred157_Java4775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20678 public static final BitSet FOLLOW_LPAREN_in_synpred157_Java4777 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L}); 20679 public static final BitSet FOLLOW_variableModifiers_in_synpred157_Java4779 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20680 public static final BitSet FOLLOW_type_in_synpred157_Java4781 = new BitSet(new long[]{0x0000000000000010L}); 20681 public static final BitSet FOLLOW_IDENTIFIER_in_synpred157_Java4783 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); 20682 public static final BitSet FOLLOW_COLON_in_synpred157_Java4785 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20683 public static final BitSet FOLLOW_expression_in_synpred157_Java4795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20684 public static final BitSet FOLLOW_RPAREN_in_synpred157_Java4797 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL}); 20685 public static final BitSet FOLLOW_statement_in_synpred157_Java4799 = new BitSet(new long[]{0x0000000000000002L}); 20686 public static final BitSet FOLLOW_localVariableDeclaration_in_synpred161_Java4962 = new BitSet(new long[]{0x0000000000000002L}); 20687 public static final BitSet FOLLOW_castExpression_in_synpred202_Java6178 = new BitSet(new long[]{0x0000000000000002L}); 20688 public static final BitSet FOLLOW_LPAREN_in_synpred206_Java6268 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20689 public static final BitSet FOLLOW_primitiveType_in_synpred206_Java6270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); 20690 public static final BitSet FOLLOW_RPAREN_in_synpred206_Java6272 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20691 public static final BitSet FOLLOW_unaryExpression_in_synpred206_Java6274 = new BitSet(new long[]{0x0000000000000002L}); 20692 public static final BitSet FOLLOW_DOT_in_synpred208_Java6332 = new BitSet(new long[]{0x0000000000000010L}); 20693 public static final BitSet FOLLOW_IDENTIFIER_in_synpred208_Java6334 = new BitSet(new long[]{0x0000000000000002L}); 20694 public static final BitSet FOLLOW_identifierSuffix_in_synpred209_Java6356 = new BitSet(new long[]{0x0000000000000002L}); 20695 public static final BitSet FOLLOW_DOT_in_synpred211_Java6388 = new BitSet(new long[]{0x0000000000000010L}); 20696 public static final BitSet FOLLOW_IDENTIFIER_in_synpred211_Java6390 = new BitSet(new long[]{0x0000000000000002L}); 20697 public static final BitSet FOLLOW_identifierSuffix_in_synpred212_Java6412 = new BitSet(new long[]{0x0000000000000002L}); 20698 public static final BitSet FOLLOW_LBRACKET_in_synpred224_Java6656 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20699 public static final BitSet FOLLOW_expression_in_synpred224_Java6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20700 public static final BitSet FOLLOW_RBRACKET_in_synpred224_Java6660 = new BitSet(new long[]{0x0000000000000002L}); 20701 public static final BitSet FOLLOW_NEW_in_synpred236_Java6866 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L}); 20702 public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868 = new BitSet(new long[]{0x0000000000000010L}); 20703 public static final BitSet FOLLOW_classOrInterfaceType_in_synpred236_Java6870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20704 public static final BitSet FOLLOW_classCreatorRest_in_synpred236_Java6872 = new BitSet(new long[]{0x0000000000000002L}); 20705 public static final BitSet FOLLOW_NEW_in_synpred237_Java6882 = new BitSet(new long[]{0x0000000000000010L}); 20706 public static final BitSet FOLLOW_classOrInterfaceType_in_synpred237_Java6884 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); 20707 public static final BitSet FOLLOW_classCreatorRest_in_synpred237_Java6886 = new BitSet(new long[]{0x0000000000000002L}); 20708 public static final BitSet FOLLOW_NEW_in_synpred239_Java6915 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L}); 20709 public static final BitSet FOLLOW_createdName_in_synpred239_Java6917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); 20710 public static final BitSet FOLLOW_LBRACKET_in_synpred239_Java6927 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20711 public static final BitSet FOLLOW_RBRACKET_in_synpred239_Java6929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); 20712 public static final BitSet FOLLOW_LBRACKET_in_synpred239_Java6940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20713 public static final BitSet FOLLOW_RBRACKET_in_synpred239_Java6942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L}); 20714 public static final BitSet FOLLOW_arrayInitializer_in_synpred239_Java6963 = new BitSet(new long[]{0x0000000000000002L}); 20715 public static final BitSet FOLLOW_LBRACKET_in_synpred240_Java7012 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L}); 20716 public static final BitSet FOLLOW_expression_in_synpred240_Java7014 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); 20717 public static final BitSet FOLLOW_RBRACKET_in_synpred240_Java7028 = new BitSet(new long[]{0x0000000000000002L}); 20718 20719 }