001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.8 002package com.puppycrawl.tools.checkstyle.grammars.javadoc; 003import org.antlr.v4.runtime.atn.*; 004import org.antlr.v4.runtime.dfa.DFA; 005import org.antlr.v4.runtime.*; 006import org.antlr.v4.runtime.misc.*; 007import org.antlr.v4.runtime.tree.*; 008import java.util.List; 009import java.util.Iterator; 010import java.util.ArrayList; 011 012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 013public class JavadocParser extends Parser { 014 static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } 015 016 protected static final DFA[] _decisionToDFA; 017 protected static final PredictionContextCache _sharedContextCache = 018 new PredictionContextCache(); 019 public static final int 020 LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 021 AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 022 RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 023 SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 024 JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 025 LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 026 STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 027 LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 028 Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 029 DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 030 LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 031 SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 032 TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 033 COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 034 HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 035 TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 036 BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 037 COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 038 INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 039 META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 040 ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91; 041 public static final int 042 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 043 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 044 RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 045 RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 046 RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 047 RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 048 RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 049 RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 050 RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 051 RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 052 RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 053 RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 054 RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 055 RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 056 RULE_baseTag = 54, RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 057 RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 058 RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 059 RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 060 RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 061 RULE_htmlComment = 73, RULE_text = 74; 062 private static String[] makeRuleNames() { 063 return new String[] { 064 "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 065 "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 066 "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 067 "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 068 "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 069 "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 070 "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 071 "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 072 "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 073 "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 074 "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 075 "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 076 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text" 077 }; 078 } 079 public static final String[] ruleNames = makeRuleNames(); 080 081 private static String[] makeLiteralNames() { 082 return new String[] { 083 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 084 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 085 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 086 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", 087 null, "','", null, null, null, null, null, null, null, null, "'@docRoot'", 088 "'@inheritDoc'", "'@link'", "'@linkplain'", null, "'@value'", null, null, 089 null, null, null, "'/'", "'='", null, null, null, null, null, null, null, 090 null, null, null, null, null, null, null, null, null, null, null, null, 091 null, null, null, null, null, null, null, null, null, null, null, null, 092 null, "'-->'" 093 }; 094 } 095 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 096 private static String[] makeSymbolicNames() { 097 return new String[] { 098 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 099 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 100 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 101 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 102 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", 103 "LITERAL_INCLUDE", "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", 104 "STRING", "PACKAGE", "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", 105 "RIGHT_BRACE", "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", 106 "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", 107 "INHERIT_DOC_LITERAL", "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", 108 "VALUE_LITERAL", "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", 109 "SLASH", "EQUALS", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", 110 "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", 111 "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", 112 "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", 113 "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", 114 "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", 115 "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 116 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "HTML_TAG_NAME", 117 "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END" 118 }; 119 } 120 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 121 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 122 123 /** 124 * @deprecated Use {@link #VOCABULARY} instead. 125 */ 126 @Deprecated 127 public static final String[] tokenNames; 128 static { 129 tokenNames = new String[_SYMBOLIC_NAMES.length]; 130 for (int i = 0; i < tokenNames.length; i++) { 131 tokenNames[i] = VOCABULARY.getLiteralName(i); 132 if (tokenNames[i] == null) { 133 tokenNames[i] = VOCABULARY.getSymbolicName(i); 134 } 135 136 if (tokenNames[i] == null) { 137 tokenNames[i] = "<INVALID>"; 138 } 139 } 140 } 141 142 @Override 143 @Deprecated 144 public String[] getTokenNames() { 145 return tokenNames; 146 } 147 148 @Override 149 150 public Vocabulary getVocabulary() { 151 return VOCABULARY; 152 } 153 154 @Override 155 public String getGrammarFileName() { return "JavadocParser.g4"; } 156 157 @Override 158 public String[] getRuleNames() { return ruleNames; } 159 160 @Override 161 public String getSerializedATN() { return _serializedATN; } 162 163 @Override 164 public ATN getATN() { return _ATN; } 165 166 167 boolean isNextJavadocTag() { 168 int token1 = _input.LA(2); 169 int token2 = _input.LA(3); 170 return isJavadocTag(token1) 171 || (token1 == WS && isJavadocTag(token2)); 172 } 173 174 boolean isJavadocTag(int type) { 175 switch(type) { 176 case AUTHOR_LITERAL: 177 case DEPRECATED_LITERAL: 178 case EXCEPTION_LITERAL: 179 case PARAM_LITERAL: 180 case RETURN_LITERAL: 181 case SEE_LITERAL: 182 case SERIAL_LITERAL: 183 case SERIAL_FIELD_LITERAL: 184 case SERIAL_DATA_LITERAL: 185 case SINCE_LITERAL: 186 case THROWS_LITERAL: 187 case VERSION_LITERAL: 188 case CUSTOM_NAME: 189 return true; 190 default: 191 return false; 192 } 193 } 194 195 boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) { 196 String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 197 String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 198 System.out.println(openTag + " - " + closeTag); 199 return openTag.equals(closeTag); 200 } 201 202 public JavadocParser(TokenStream input) { 203 super(input); 204 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 205 } 206 207 public static class JavadocContext extends ParserRuleContext { 208 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 209 public List<HtmlElementContext> htmlElement() { 210 return getRuleContexts(HtmlElementContext.class); 211 } 212 public HtmlElementContext htmlElement(int i) { 213 return getRuleContext(HtmlElementContext.class,i); 214 } 215 public List<HtmlCommentContext> htmlComment() { 216 return getRuleContexts(HtmlCommentContext.class); 217 } 218 public HtmlCommentContext htmlComment(int i) { 219 return getRuleContext(HtmlCommentContext.class,i); 220 } 221 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 222 public TerminalNode CDATA(int i) { 223 return getToken(JavadocParser.CDATA, i); 224 } 225 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 226 public TerminalNode NEWLINE(int i) { 227 return getToken(JavadocParser.NEWLINE, i); 228 } 229 public List<TextContext> text() { 230 return getRuleContexts(TextContext.class); 231 } 232 public TextContext text(int i) { 233 return getRuleContext(TextContext.class,i); 234 } 235 public List<JavadocInlineTagContext> javadocInlineTag() { 236 return getRuleContexts(JavadocInlineTagContext.class); 237 } 238 public JavadocInlineTagContext javadocInlineTag(int i) { 239 return getRuleContext(JavadocInlineTagContext.class,i); 240 } 241 public List<JavadocTagContext> javadocTag() { 242 return getRuleContexts(JavadocTagContext.class); 243 } 244 public JavadocTagContext javadocTag(int i) { 245 return getRuleContext(JavadocTagContext.class,i); 246 } 247 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 248 public TerminalNode LEADING_ASTERISK(int i) { 249 return getToken(JavadocParser.LEADING_ASTERISK, i); 250 } 251 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 252 public TerminalNode WS(int i) { 253 return getToken(JavadocParser.WS, i); 254 } 255 public JavadocContext(ParserRuleContext parent, int invokingState) { 256 super(parent, invokingState); 257 } 258 @Override public int getRuleIndex() { return RULE_javadoc; } 259 @Override 260 public void enterRule(ParseTreeListener listener) { 261 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this); 262 } 263 @Override 264 public void exitRule(ParseTreeListener listener) { 265 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this); 266 } 267 @Override 268 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 269 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); 270 else return visitor.visitChildren(this); 271 } 272 } 273 274 public final JavadocContext javadoc() throws RecognitionException { 275 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 276 enterRule(_localctx, 0, RULE_javadoc); 277 int _la; 278 try { 279 int _alt; 280 enterOuterAlt(_localctx, 1); 281 { 282 setState(160); 283 _errHandler.sync(this); 284 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 285 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 286 if ( _alt==1 ) { 287 { 288 setState(158); 289 _errHandler.sync(this); 290 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 291 case 1: 292 { 293 setState(150); 294 htmlElement(); 295 } 296 break; 297 case 2: 298 { 299 { 300 setState(151); 301 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 302 setState(152); 303 match(LEADING_ASTERISK); 304 } 305 } 306 break; 307 case 3: 308 { 309 setState(153); 310 htmlComment(); 311 } 312 break; 313 case 4: 314 { 315 setState(154); 316 match(CDATA); 317 } 318 break; 319 case 5: 320 { 321 setState(155); 322 match(NEWLINE); 323 } 324 break; 325 case 6: 326 { 327 setState(156); 328 text(); 329 } 330 break; 331 case 7: 332 { 333 setState(157); 334 javadocInlineTag(); 335 } 336 break; 337 } 338 } 339 } 340 setState(162); 341 _errHandler.sync(this); 342 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 343 } 344 setState(175); 345 _errHandler.sync(this); 346 _la = _input.LA(1); 347 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << AUTHOR_LITERAL) | (1L << DEPRECATED_LITERAL) | (1L << EXCEPTION_LITERAL) | (1L << PARAM_LITERAL) | (1L << RETURN_LITERAL) | (1L << SEE_LITERAL) | (1L << SERIAL_LITERAL) | (1L << SERIAL_FIELD_LITERAL) | (1L << SERIAL_DATA_LITERAL) | (1L << SINCE_LITERAL) | (1L << THROWS_LITERAL) | (1L << VERSION_LITERAL) | (1L << CUSTOM_NAME))) != 0)) { 348 { 349 { 350 setState(164); 351 _errHandler.sync(this); 352 _la = _input.LA(1); 353 if (_la==LEADING_ASTERISK) { 354 { 355 setState(163); 356 match(LEADING_ASTERISK); 357 } 358 } 359 360 setState(169); 361 _errHandler.sync(this); 362 _la = _input.LA(1); 363 while (_la==WS) { 364 { 365 { 366 setState(166); 367 match(WS); 368 } 369 } 370 setState(171); 371 _errHandler.sync(this); 372 _la = _input.LA(1); 373 } 374 setState(172); 375 javadocTag(); 376 } 377 } 378 setState(177); 379 _errHandler.sync(this); 380 _la = _input.LA(1); 381 } 382 setState(178); 383 match(EOF); 384 } 385 } 386 catch (RecognitionException re) { 387 _localctx.exception = re; 388 _errHandler.reportError(this, re); 389 _errHandler.recover(this, re); 390 } 391 finally { 392 exitRule(); 393 } 394 return _localctx; 395 } 396 397 public static class HtmlElementContext extends ParserRuleContext { 398 public HtmlTagContext htmlTag() { 399 return getRuleContext(HtmlTagContext.class,0); 400 } 401 public SingletonElementContext singletonElement() { 402 return getRuleContext(SingletonElementContext.class,0); 403 } 404 public ParagraphContext paragraph() { 405 return getRuleContext(ParagraphContext.class,0); 406 } 407 public LiContext li() { 408 return getRuleContext(LiContext.class,0); 409 } 410 public TrContext tr() { 411 return getRuleContext(TrContext.class,0); 412 } 413 public TdContext td() { 414 return getRuleContext(TdContext.class,0); 415 } 416 public ThContext th() { 417 return getRuleContext(ThContext.class,0); 418 } 419 public BodyContext body() { 420 return getRuleContext(BodyContext.class,0); 421 } 422 public ColgroupContext colgroup() { 423 return getRuleContext(ColgroupContext.class,0); 424 } 425 public DdContext dd() { 426 return getRuleContext(DdContext.class,0); 427 } 428 public DtContext dt() { 429 return getRuleContext(DtContext.class,0); 430 } 431 public HeadContext head() { 432 return getRuleContext(HeadContext.class,0); 433 } 434 public HtmlContext html() { 435 return getRuleContext(HtmlContext.class,0); 436 } 437 public OptionContext option() { 438 return getRuleContext(OptionContext.class,0); 439 } 440 public TbodyContext tbody() { 441 return getRuleContext(TbodyContext.class,0); 442 } 443 public TheadContext thead() { 444 return getRuleContext(TheadContext.class,0); 445 } 446 public TfootContext tfoot() { 447 return getRuleContext(TfootContext.class,0); 448 } 449 public PTagOpenContext pTagOpen() { 450 return getRuleContext(PTagOpenContext.class,0); 451 } 452 public LiTagOpenContext liTagOpen() { 453 return getRuleContext(LiTagOpenContext.class,0); 454 } 455 public TrTagOpenContext trTagOpen() { 456 return getRuleContext(TrTagOpenContext.class,0); 457 } 458 public TdTagOpenContext tdTagOpen() { 459 return getRuleContext(TdTagOpenContext.class,0); 460 } 461 public ThTagOpenContext thTagOpen() { 462 return getRuleContext(ThTagOpenContext.class,0); 463 } 464 public BodyTagOpenContext bodyTagOpen() { 465 return getRuleContext(BodyTagOpenContext.class,0); 466 } 467 public ColgroupTagOpenContext colgroupTagOpen() { 468 return getRuleContext(ColgroupTagOpenContext.class,0); 469 } 470 public DdTagOpenContext ddTagOpen() { 471 return getRuleContext(DdTagOpenContext.class,0); 472 } 473 public DtTagOpenContext dtTagOpen() { 474 return getRuleContext(DtTagOpenContext.class,0); 475 } 476 public HeadTagOpenContext headTagOpen() { 477 return getRuleContext(HeadTagOpenContext.class,0); 478 } 479 public HtmlTagOpenContext htmlTagOpen() { 480 return getRuleContext(HtmlTagOpenContext.class,0); 481 } 482 public OptionTagOpenContext optionTagOpen() { 483 return getRuleContext(OptionTagOpenContext.class,0); 484 } 485 public TbodyTagOpenContext tbodyTagOpen() { 486 return getRuleContext(TbodyTagOpenContext.class,0); 487 } 488 public TheadTagOpenContext theadTagOpen() { 489 return getRuleContext(TheadTagOpenContext.class,0); 490 } 491 public TfootTagOpenContext tfootTagOpen() { 492 return getRuleContext(TfootTagOpenContext.class,0); 493 } 494 public PTagCloseContext pTagClose() { 495 return getRuleContext(PTagCloseContext.class,0); 496 } 497 public LiTagCloseContext liTagClose() { 498 return getRuleContext(LiTagCloseContext.class,0); 499 } 500 public TrTagCloseContext trTagClose() { 501 return getRuleContext(TrTagCloseContext.class,0); 502 } 503 public TdTagCloseContext tdTagClose() { 504 return getRuleContext(TdTagCloseContext.class,0); 505 } 506 public ThTagCloseContext thTagClose() { 507 return getRuleContext(ThTagCloseContext.class,0); 508 } 509 public BodyTagCloseContext bodyTagClose() { 510 return getRuleContext(BodyTagCloseContext.class,0); 511 } 512 public ColgroupTagCloseContext colgroupTagClose() { 513 return getRuleContext(ColgroupTagCloseContext.class,0); 514 } 515 public DdTagCloseContext ddTagClose() { 516 return getRuleContext(DdTagCloseContext.class,0); 517 } 518 public DtTagCloseContext dtTagClose() { 519 return getRuleContext(DtTagCloseContext.class,0); 520 } 521 public HeadTagCloseContext headTagClose() { 522 return getRuleContext(HeadTagCloseContext.class,0); 523 } 524 public HtmlTagCloseContext htmlTagClose() { 525 return getRuleContext(HtmlTagCloseContext.class,0); 526 } 527 public OptionTagCloseContext optionTagClose() { 528 return getRuleContext(OptionTagCloseContext.class,0); 529 } 530 public TbodyTagCloseContext tbodyTagClose() { 531 return getRuleContext(TbodyTagCloseContext.class,0); 532 } 533 public TheadTagCloseContext theadTagClose() { 534 return getRuleContext(TheadTagCloseContext.class,0); 535 } 536 public TfootTagCloseContext tfootTagClose() { 537 return getRuleContext(TfootTagCloseContext.class,0); 538 } 539 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 540 super(parent, invokingState); 541 } 542 @Override public int getRuleIndex() { return RULE_htmlElement; } 543 @Override 544 public void enterRule(ParseTreeListener listener) { 545 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 546 } 547 @Override 548 public void exitRule(ParseTreeListener listener) { 549 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 550 } 551 @Override 552 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 553 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 554 else return visitor.visitChildren(this); 555 } 556 } 557 558 public final HtmlElementContext htmlElement() throws RecognitionException { 559 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 560 enterRule(_localctx, 2, RULE_htmlElement); 561 try { 562 setState(227); 563 _errHandler.sync(this); 564 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 565 case 1: 566 enterOuterAlt(_localctx, 1); 567 { 568 setState(180); 569 htmlTag(); 570 } 571 break; 572 case 2: 573 enterOuterAlt(_localctx, 2); 574 { 575 setState(181); 576 singletonElement(); 577 } 578 break; 579 case 3: 580 enterOuterAlt(_localctx, 3); 581 { 582 setState(182); 583 paragraph(); 584 } 585 break; 586 case 4: 587 enterOuterAlt(_localctx, 4); 588 { 589 setState(183); 590 li(); 591 } 592 break; 593 case 5: 594 enterOuterAlt(_localctx, 5); 595 { 596 setState(184); 597 tr(); 598 } 599 break; 600 case 6: 601 enterOuterAlt(_localctx, 6); 602 { 603 setState(185); 604 td(); 605 } 606 break; 607 case 7: 608 enterOuterAlt(_localctx, 7); 609 { 610 setState(186); 611 th(); 612 } 613 break; 614 case 8: 615 enterOuterAlt(_localctx, 8); 616 { 617 setState(187); 618 body(); 619 } 620 break; 621 case 9: 622 enterOuterAlt(_localctx, 9); 623 { 624 setState(188); 625 colgroup(); 626 } 627 break; 628 case 10: 629 enterOuterAlt(_localctx, 10); 630 { 631 setState(189); 632 dd(); 633 } 634 break; 635 case 11: 636 enterOuterAlt(_localctx, 11); 637 { 638 setState(190); 639 dt(); 640 } 641 break; 642 case 12: 643 enterOuterAlt(_localctx, 12); 644 { 645 setState(191); 646 head(); 647 } 648 break; 649 case 13: 650 enterOuterAlt(_localctx, 13); 651 { 652 setState(192); 653 html(); 654 } 655 break; 656 case 14: 657 enterOuterAlt(_localctx, 14); 658 { 659 setState(193); 660 option(); 661 } 662 break; 663 case 15: 664 enterOuterAlt(_localctx, 15); 665 { 666 setState(194); 667 tbody(); 668 } 669 break; 670 case 16: 671 enterOuterAlt(_localctx, 16); 672 { 673 setState(195); 674 thead(); 675 } 676 break; 677 case 17: 678 enterOuterAlt(_localctx, 17); 679 { 680 setState(196); 681 tfoot(); 682 } 683 break; 684 case 18: 685 enterOuterAlt(_localctx, 18); 686 { 687 setState(197); 688 pTagOpen(); 689 } 690 break; 691 case 19: 692 enterOuterAlt(_localctx, 19); 693 { 694 setState(198); 695 liTagOpen(); 696 } 697 break; 698 case 20: 699 enterOuterAlt(_localctx, 20); 700 { 701 setState(199); 702 trTagOpen(); 703 } 704 break; 705 case 21: 706 enterOuterAlt(_localctx, 21); 707 { 708 setState(200); 709 tdTagOpen(); 710 } 711 break; 712 case 22: 713 enterOuterAlt(_localctx, 22); 714 { 715 setState(201); 716 thTagOpen(); 717 } 718 break; 719 case 23: 720 enterOuterAlt(_localctx, 23); 721 { 722 setState(202); 723 bodyTagOpen(); 724 } 725 break; 726 case 24: 727 enterOuterAlt(_localctx, 24); 728 { 729 setState(203); 730 colgroupTagOpen(); 731 } 732 break; 733 case 25: 734 enterOuterAlt(_localctx, 25); 735 { 736 setState(204); 737 ddTagOpen(); 738 } 739 break; 740 case 26: 741 enterOuterAlt(_localctx, 26); 742 { 743 setState(205); 744 dtTagOpen(); 745 } 746 break; 747 case 27: 748 enterOuterAlt(_localctx, 27); 749 { 750 setState(206); 751 headTagOpen(); 752 } 753 break; 754 case 28: 755 enterOuterAlt(_localctx, 28); 756 { 757 setState(207); 758 htmlTagOpen(); 759 } 760 break; 761 case 29: 762 enterOuterAlt(_localctx, 29); 763 { 764 setState(208); 765 optionTagOpen(); 766 } 767 break; 768 case 30: 769 enterOuterAlt(_localctx, 30); 770 { 771 setState(209); 772 tbodyTagOpen(); 773 } 774 break; 775 case 31: 776 enterOuterAlt(_localctx, 31); 777 { 778 setState(210); 779 theadTagOpen(); 780 } 781 break; 782 case 32: 783 enterOuterAlt(_localctx, 32); 784 { 785 setState(211); 786 tfootTagOpen(); 787 } 788 break; 789 case 33: 790 enterOuterAlt(_localctx, 33); 791 { 792 setState(212); 793 pTagClose(); 794 } 795 break; 796 case 34: 797 enterOuterAlt(_localctx, 34); 798 { 799 setState(213); 800 liTagClose(); 801 } 802 break; 803 case 35: 804 enterOuterAlt(_localctx, 35); 805 { 806 setState(214); 807 trTagClose(); 808 } 809 break; 810 case 36: 811 enterOuterAlt(_localctx, 36); 812 { 813 setState(215); 814 tdTagClose(); 815 } 816 break; 817 case 37: 818 enterOuterAlt(_localctx, 37); 819 { 820 setState(216); 821 thTagClose(); 822 } 823 break; 824 case 38: 825 enterOuterAlt(_localctx, 38); 826 { 827 setState(217); 828 bodyTagClose(); 829 } 830 break; 831 case 39: 832 enterOuterAlt(_localctx, 39); 833 { 834 setState(218); 835 colgroupTagClose(); 836 } 837 break; 838 case 40: 839 enterOuterAlt(_localctx, 40); 840 { 841 setState(219); 842 ddTagClose(); 843 } 844 break; 845 case 41: 846 enterOuterAlt(_localctx, 41); 847 { 848 setState(220); 849 dtTagClose(); 850 } 851 break; 852 case 42: 853 enterOuterAlt(_localctx, 42); 854 { 855 setState(221); 856 headTagClose(); 857 } 858 break; 859 case 43: 860 enterOuterAlt(_localctx, 43); 861 { 862 setState(222); 863 htmlTagClose(); 864 } 865 break; 866 case 44: 867 enterOuterAlt(_localctx, 44); 868 { 869 setState(223); 870 optionTagClose(); 871 } 872 break; 873 case 45: 874 enterOuterAlt(_localctx, 45); 875 { 876 setState(224); 877 tbodyTagClose(); 878 } 879 break; 880 case 46: 881 enterOuterAlt(_localctx, 46); 882 { 883 setState(225); 884 theadTagClose(); 885 } 886 break; 887 case 47: 888 enterOuterAlt(_localctx, 47); 889 { 890 setState(226); 891 tfootTagClose(); 892 } 893 break; 894 } 895 } 896 catch (RecognitionException re) { 897 _localctx.exception = re; 898 _errHandler.reportError(this, re); 899 _errHandler.recover(this, re); 900 } 901 finally { 902 exitRule(); 903 } 904 return _localctx; 905 } 906 907 public static class HtmlElementOpenContext extends ParserRuleContext { 908 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 909 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 910 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 911 public List<AttributeContext> attribute() { 912 return getRuleContexts(AttributeContext.class); 913 } 914 public AttributeContext attribute(int i) { 915 return getRuleContext(AttributeContext.class,i); 916 } 917 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 918 public TerminalNode NEWLINE(int i) { 919 return getToken(JavadocParser.NEWLINE, i); 920 } 921 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 922 public TerminalNode LEADING_ASTERISK(int i) { 923 return getToken(JavadocParser.LEADING_ASTERISK, i); 924 } 925 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 926 public TerminalNode WS(int i) { 927 return getToken(JavadocParser.WS, i); 928 } 929 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 930 super(parent, invokingState); 931 } 932 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 933 @Override 934 public void enterRule(ParseTreeListener listener) { 935 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 936 } 937 @Override 938 public void exitRule(ParseTreeListener listener) { 939 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 940 } 941 @Override 942 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 943 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 944 else return visitor.visitChildren(this); 945 } 946 } 947 948 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 949 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 950 enterRule(_localctx, 4, RULE_htmlElementOpen); 951 int _la; 952 try { 953 enterOuterAlt(_localctx, 1); 954 { 955 setState(229); 956 match(OPEN); 957 setState(230); 958 match(HTML_TAG_NAME); 959 setState(237); 960 _errHandler.sync(this); 961 _la = _input.LA(1); 962 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 963 { 964 setState(235); 965 _errHandler.sync(this); 966 switch (_input.LA(1)) { 967 case HTML_TAG_NAME: 968 { 969 setState(231); 970 attribute(); 971 } 972 break; 973 case NEWLINE: 974 { 975 setState(232); 976 match(NEWLINE); 977 } 978 break; 979 case LEADING_ASTERISK: 980 { 981 setState(233); 982 match(LEADING_ASTERISK); 983 } 984 break; 985 case WS: 986 { 987 setState(234); 988 match(WS); 989 } 990 break; 991 default: 992 throw new NoViableAltException(this); 993 } 994 } 995 setState(239); 996 _errHandler.sync(this); 997 _la = _input.LA(1); 998 } 999 setState(240); 1000 match(CLOSE); 1001 } 1002 } 1003 catch (RecognitionException re) { 1004 _localctx.exception = re; 1005 _errHandler.reportError(this, re); 1006 _errHandler.recover(this, re); 1007 } 1008 finally { 1009 exitRule(); 1010 } 1011 return _localctx; 1012 } 1013 1014 public static class HtmlElementCloseContext extends ParserRuleContext { 1015 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1016 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1017 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1018 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1019 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1020 public TerminalNode NEWLINE(int i) { 1021 return getToken(JavadocParser.NEWLINE, i); 1022 } 1023 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1024 public TerminalNode LEADING_ASTERISK(int i) { 1025 return getToken(JavadocParser.LEADING_ASTERISK, i); 1026 } 1027 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1028 public TerminalNode WS(int i) { 1029 return getToken(JavadocParser.WS, i); 1030 } 1031 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1032 super(parent, invokingState); 1033 } 1034 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1035 @Override 1036 public void enterRule(ParseTreeListener listener) { 1037 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1038 } 1039 @Override 1040 public void exitRule(ParseTreeListener listener) { 1041 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1042 } 1043 @Override 1044 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1045 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1046 else return visitor.visitChildren(this); 1047 } 1048 } 1049 1050 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1051 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1052 enterRule(_localctx, 6, RULE_htmlElementClose); 1053 int _la; 1054 try { 1055 enterOuterAlt(_localctx, 1); 1056 { 1057 setState(242); 1058 match(OPEN); 1059 setState(243); 1060 match(SLASH); 1061 setState(244); 1062 match(HTML_TAG_NAME); 1063 setState(248); 1064 _errHandler.sync(this); 1065 _la = _input.LA(1); 1066 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1067 { 1068 { 1069 setState(245); 1070 _la = _input.LA(1); 1071 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1072 _errHandler.recoverInline(this); 1073 } 1074 else { 1075 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1076 _errHandler.reportMatch(this); 1077 consume(); 1078 } 1079 } 1080 } 1081 setState(250); 1082 _errHandler.sync(this); 1083 _la = _input.LA(1); 1084 } 1085 setState(251); 1086 match(CLOSE); 1087 } 1088 } 1089 catch (RecognitionException re) { 1090 _localctx.exception = re; 1091 _errHandler.reportError(this, re); 1092 _errHandler.recover(this, re); 1093 } 1094 finally { 1095 exitRule(); 1096 } 1097 return _localctx; 1098 } 1099 1100 public static class AttributeContext extends ParserRuleContext { 1101 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1102 public TerminalNode HTML_TAG_NAME(int i) { 1103 return getToken(JavadocParser.HTML_TAG_NAME, i); 1104 } 1105 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1106 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1107 public TextContext text() { 1108 return getRuleContext(TextContext.class,0); 1109 } 1110 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1111 public TerminalNode NEWLINE(int i) { 1112 return getToken(JavadocParser.NEWLINE, i); 1113 } 1114 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1115 public TerminalNode LEADING_ASTERISK(int i) { 1116 return getToken(JavadocParser.LEADING_ASTERISK, i); 1117 } 1118 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1119 public TerminalNode WS(int i) { 1120 return getToken(JavadocParser.WS, i); 1121 } 1122 public AttributeContext(ParserRuleContext parent, int invokingState) { 1123 super(parent, invokingState); 1124 } 1125 @Override public int getRuleIndex() { return RULE_attribute; } 1126 @Override 1127 public void enterRule(ParseTreeListener listener) { 1128 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1129 } 1130 @Override 1131 public void exitRule(ParseTreeListener listener) { 1132 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1133 } 1134 @Override 1135 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1136 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1137 else return visitor.visitChildren(this); 1138 } 1139 } 1140 1141 public final AttributeContext attribute() throws RecognitionException { 1142 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1143 enterRule(_localctx, 8, RULE_attribute); 1144 int _la; 1145 try { 1146 int _alt; 1147 enterOuterAlt(_localctx, 1); 1148 { 1149 setState(253); 1150 match(HTML_TAG_NAME); 1151 setState(257); 1152 _errHandler.sync(this); 1153 _la = _input.LA(1); 1154 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1155 { 1156 { 1157 setState(254); 1158 _la = _input.LA(1); 1159 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1160 _errHandler.recoverInline(this); 1161 } 1162 else { 1163 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1164 _errHandler.reportMatch(this); 1165 consume(); 1166 } 1167 } 1168 } 1169 setState(259); 1170 _errHandler.sync(this); 1171 _la = _input.LA(1); 1172 } 1173 setState(260); 1174 match(EQUALS); 1175 setState(264); 1176 _errHandler.sync(this); 1177 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1178 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1179 if ( _alt==1 ) { 1180 { 1181 { 1182 setState(261); 1183 _la = _input.LA(1); 1184 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1185 _errHandler.recoverInline(this); 1186 } 1187 else { 1188 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1189 _errHandler.reportMatch(this); 1190 consume(); 1191 } 1192 } 1193 } 1194 } 1195 setState(266); 1196 _errHandler.sync(this); 1197 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1198 } 1199 setState(270); 1200 _errHandler.sync(this); 1201 switch (_input.LA(1)) { 1202 case ATTR_VALUE: 1203 { 1204 setState(267); 1205 match(ATTR_VALUE); 1206 } 1207 break; 1208 case WS: 1209 case CHAR: 1210 { 1211 setState(268); 1212 text(); 1213 } 1214 break; 1215 case HTML_TAG_NAME: 1216 { 1217 setState(269); 1218 match(HTML_TAG_NAME); 1219 } 1220 break; 1221 default: 1222 throw new NoViableAltException(this); 1223 } 1224 } 1225 } 1226 catch (RecognitionException re) { 1227 _localctx.exception = re; 1228 _errHandler.reportError(this, re); 1229 _errHandler.recover(this, re); 1230 } 1231 finally { 1232 exitRule(); 1233 } 1234 return _localctx; 1235 } 1236 1237 public static class HtmlTagContext extends ParserRuleContext { 1238 public HtmlElementOpenContext htmlElementOpen; 1239 public HtmlElementOpenContext htmlElementOpen() { 1240 return getRuleContext(HtmlElementOpenContext.class,0); 1241 } 1242 public HtmlElementCloseContext htmlElementClose() { 1243 return getRuleContext(HtmlElementCloseContext.class,0); 1244 } 1245 public List<HtmlElementContext> htmlElement() { 1246 return getRuleContexts(HtmlElementContext.class); 1247 } 1248 public HtmlElementContext htmlElement(int i) { 1249 return getRuleContext(HtmlElementContext.class,i); 1250 } 1251 public List<HtmlCommentContext> htmlComment() { 1252 return getRuleContexts(HtmlCommentContext.class); 1253 } 1254 public HtmlCommentContext htmlComment(int i) { 1255 return getRuleContext(HtmlCommentContext.class,i); 1256 } 1257 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1258 public TerminalNode CDATA(int i) { 1259 return getToken(JavadocParser.CDATA, i); 1260 } 1261 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1262 public TerminalNode NEWLINE(int i) { 1263 return getToken(JavadocParser.NEWLINE, i); 1264 } 1265 public List<TextContext> text() { 1266 return getRuleContexts(TextContext.class); 1267 } 1268 public TextContext text(int i) { 1269 return getRuleContext(TextContext.class,i); 1270 } 1271 public List<JavadocInlineTagContext> javadocInlineTag() { 1272 return getRuleContexts(JavadocInlineTagContext.class); 1273 } 1274 public JavadocInlineTagContext javadocInlineTag(int i) { 1275 return getRuleContext(JavadocInlineTagContext.class,i); 1276 } 1277 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1278 public TerminalNode LEADING_ASTERISK(int i) { 1279 return getToken(JavadocParser.LEADING_ASTERISK, i); 1280 } 1281 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1282 super(parent, invokingState); 1283 } 1284 @Override public int getRuleIndex() { return RULE_htmlTag; } 1285 @Override 1286 public void enterRule(ParseTreeListener listener) { 1287 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1288 } 1289 @Override 1290 public void exitRule(ParseTreeListener listener) { 1291 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1292 } 1293 @Override 1294 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1295 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1296 else return visitor.visitChildren(this); 1297 } 1298 } 1299 1300 public final HtmlTagContext htmlTag() throws RecognitionException { 1301 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1302 enterRule(_localctx, 10, RULE_htmlTag); 1303 try { 1304 int _alt; 1305 setState(304); 1306 _errHandler.sync(this); 1307 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1308 case 1: 1309 enterOuterAlt(_localctx, 1); 1310 { 1311 setState(272); 1312 htmlElementOpen(); 1313 setState(283); 1314 _errHandler.sync(this); 1315 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1316 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1317 if ( _alt==1 ) { 1318 { 1319 setState(281); 1320 _errHandler.sync(this); 1321 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1322 case 1: 1323 { 1324 setState(273); 1325 htmlElement(); 1326 } 1327 break; 1328 case 2: 1329 { 1330 { 1331 setState(274); 1332 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1333 setState(275); 1334 match(LEADING_ASTERISK); 1335 } 1336 } 1337 break; 1338 case 3: 1339 { 1340 setState(276); 1341 htmlComment(); 1342 } 1343 break; 1344 case 4: 1345 { 1346 setState(277); 1347 match(CDATA); 1348 } 1349 break; 1350 case 5: 1351 { 1352 setState(278); 1353 match(NEWLINE); 1354 } 1355 break; 1356 case 6: 1357 { 1358 setState(279); 1359 text(); 1360 } 1361 break; 1362 case 7: 1363 { 1364 setState(280); 1365 javadocInlineTag(); 1366 } 1367 break; 1368 } 1369 } 1370 } 1371 setState(285); 1372 _errHandler.sync(this); 1373 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1374 } 1375 setState(286); 1376 htmlElementClose(); 1377 } 1378 break; 1379 case 2: 1380 enterOuterAlt(_localctx, 2); 1381 { 1382 setState(288); 1383 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1384 setState(299); 1385 _errHandler.sync(this); 1386 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1387 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1388 if ( _alt==1 ) { 1389 { 1390 setState(297); 1391 _errHandler.sync(this); 1392 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1393 case 1: 1394 { 1395 setState(289); 1396 htmlElement(); 1397 } 1398 break; 1399 case 2: 1400 { 1401 { 1402 setState(290); 1403 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1404 setState(291); 1405 match(LEADING_ASTERISK); 1406 } 1407 } 1408 break; 1409 case 3: 1410 { 1411 setState(292); 1412 htmlComment(); 1413 } 1414 break; 1415 case 4: 1416 { 1417 setState(293); 1418 match(CDATA); 1419 } 1420 break; 1421 case 5: 1422 { 1423 setState(294); 1424 match(NEWLINE); 1425 } 1426 break; 1427 case 6: 1428 { 1429 setState(295); 1430 text(); 1431 } 1432 break; 1433 case 7: 1434 { 1435 setState(296); 1436 javadocInlineTag(); 1437 } 1438 break; 1439 } 1440 } 1441 } 1442 setState(301); 1443 _errHandler.sync(this); 1444 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1445 } 1446 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol() 1447 , "javadoc.missed.html.close", null); 1448 } 1449 break; 1450 } 1451 } 1452 catch (RecognitionException re) { 1453 _localctx.exception = re; 1454 _errHandler.reportError(this, re); 1455 _errHandler.recover(this, re); 1456 } 1457 finally { 1458 exitRule(); 1459 } 1460 return _localctx; 1461 } 1462 1463 public static class PTagOpenContext extends ParserRuleContext { 1464 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1465 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1466 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1467 public List<AttributeContext> attribute() { 1468 return getRuleContexts(AttributeContext.class); 1469 } 1470 public AttributeContext attribute(int i) { 1471 return getRuleContext(AttributeContext.class,i); 1472 } 1473 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1474 public TerminalNode NEWLINE(int i) { 1475 return getToken(JavadocParser.NEWLINE, i); 1476 } 1477 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1478 public TerminalNode LEADING_ASTERISK(int i) { 1479 return getToken(JavadocParser.LEADING_ASTERISK, i); 1480 } 1481 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1482 public TerminalNode WS(int i) { 1483 return getToken(JavadocParser.WS, i); 1484 } 1485 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1486 super(parent, invokingState); 1487 } 1488 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1489 @Override 1490 public void enterRule(ParseTreeListener listener) { 1491 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1492 } 1493 @Override 1494 public void exitRule(ParseTreeListener listener) { 1495 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1496 } 1497 @Override 1498 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1499 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1500 else return visitor.visitChildren(this); 1501 } 1502 } 1503 1504 public final PTagOpenContext pTagOpen() throws RecognitionException { 1505 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1506 enterRule(_localctx, 12, RULE_pTagOpen); 1507 int _la; 1508 try { 1509 enterOuterAlt(_localctx, 1); 1510 { 1511 setState(306); 1512 match(OPEN); 1513 setState(307); 1514 match(P_HTML_TAG_NAME); 1515 setState(314); 1516 _errHandler.sync(this); 1517 _la = _input.LA(1); 1518 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1519 { 1520 setState(312); 1521 _errHandler.sync(this); 1522 switch (_input.LA(1)) { 1523 case HTML_TAG_NAME: 1524 { 1525 setState(308); 1526 attribute(); 1527 } 1528 break; 1529 case NEWLINE: 1530 { 1531 setState(309); 1532 match(NEWLINE); 1533 } 1534 break; 1535 case LEADING_ASTERISK: 1536 { 1537 setState(310); 1538 match(LEADING_ASTERISK); 1539 } 1540 break; 1541 case WS: 1542 { 1543 setState(311); 1544 match(WS); 1545 } 1546 break; 1547 default: 1548 throw new NoViableAltException(this); 1549 } 1550 } 1551 setState(316); 1552 _errHandler.sync(this); 1553 _la = _input.LA(1); 1554 } 1555 setState(317); 1556 match(CLOSE); 1557 } 1558 } 1559 catch (RecognitionException re) { 1560 _localctx.exception = re; 1561 _errHandler.reportError(this, re); 1562 _errHandler.recover(this, re); 1563 } 1564 finally { 1565 exitRule(); 1566 } 1567 return _localctx; 1568 } 1569 1570 public static class PTagCloseContext extends ParserRuleContext { 1571 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1572 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1573 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1574 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1575 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1576 public TerminalNode NEWLINE(int i) { 1577 return getToken(JavadocParser.NEWLINE, i); 1578 } 1579 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1580 public TerminalNode LEADING_ASTERISK(int i) { 1581 return getToken(JavadocParser.LEADING_ASTERISK, i); 1582 } 1583 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1584 public TerminalNode WS(int i) { 1585 return getToken(JavadocParser.WS, i); 1586 } 1587 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1588 super(parent, invokingState); 1589 } 1590 @Override public int getRuleIndex() { return RULE_pTagClose; } 1591 @Override 1592 public void enterRule(ParseTreeListener listener) { 1593 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1594 } 1595 @Override 1596 public void exitRule(ParseTreeListener listener) { 1597 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1598 } 1599 @Override 1600 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1601 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1602 else return visitor.visitChildren(this); 1603 } 1604 } 1605 1606 public final PTagCloseContext pTagClose() throws RecognitionException { 1607 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1608 enterRule(_localctx, 14, RULE_pTagClose); 1609 int _la; 1610 try { 1611 enterOuterAlt(_localctx, 1); 1612 { 1613 setState(319); 1614 match(OPEN); 1615 setState(320); 1616 match(SLASH); 1617 setState(321); 1618 match(P_HTML_TAG_NAME); 1619 setState(325); 1620 _errHandler.sync(this); 1621 _la = _input.LA(1); 1622 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1623 { 1624 { 1625 setState(322); 1626 _la = _input.LA(1); 1627 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1628 _errHandler.recoverInline(this); 1629 } 1630 else { 1631 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1632 _errHandler.reportMatch(this); 1633 consume(); 1634 } 1635 } 1636 } 1637 setState(327); 1638 _errHandler.sync(this); 1639 _la = _input.LA(1); 1640 } 1641 setState(328); 1642 match(CLOSE); 1643 } 1644 } 1645 catch (RecognitionException re) { 1646 _localctx.exception = re; 1647 _errHandler.reportError(this, re); 1648 _errHandler.recover(this, re); 1649 } 1650 finally { 1651 exitRule(); 1652 } 1653 return _localctx; 1654 } 1655 1656 public static class ParagraphContext extends ParserRuleContext { 1657 public PTagOpenContext pTagOpen() { 1658 return getRuleContext(PTagOpenContext.class,0); 1659 } 1660 public PTagCloseContext pTagClose() { 1661 return getRuleContext(PTagCloseContext.class,0); 1662 } 1663 public List<HtmlTagContext> htmlTag() { 1664 return getRuleContexts(HtmlTagContext.class); 1665 } 1666 public HtmlTagContext htmlTag(int i) { 1667 return getRuleContext(HtmlTagContext.class,i); 1668 } 1669 public List<SingletonTagContext> singletonTag() { 1670 return getRuleContexts(SingletonTagContext.class); 1671 } 1672 public SingletonTagContext singletonTag(int i) { 1673 return getRuleContext(SingletonTagContext.class,i); 1674 } 1675 public List<LiContext> li() { 1676 return getRuleContexts(LiContext.class); 1677 } 1678 public LiContext li(int i) { 1679 return getRuleContext(LiContext.class,i); 1680 } 1681 public List<TrContext> tr() { 1682 return getRuleContexts(TrContext.class); 1683 } 1684 public TrContext tr(int i) { 1685 return getRuleContext(TrContext.class,i); 1686 } 1687 public List<TdContext> td() { 1688 return getRuleContexts(TdContext.class); 1689 } 1690 public TdContext td(int i) { 1691 return getRuleContext(TdContext.class,i); 1692 } 1693 public List<ThContext> th() { 1694 return getRuleContexts(ThContext.class); 1695 } 1696 public ThContext th(int i) { 1697 return getRuleContext(ThContext.class,i); 1698 } 1699 public List<BodyContext> body() { 1700 return getRuleContexts(BodyContext.class); 1701 } 1702 public BodyContext body(int i) { 1703 return getRuleContext(BodyContext.class,i); 1704 } 1705 public List<ColgroupContext> colgroup() { 1706 return getRuleContexts(ColgroupContext.class); 1707 } 1708 public ColgroupContext colgroup(int i) { 1709 return getRuleContext(ColgroupContext.class,i); 1710 } 1711 public List<DdContext> dd() { 1712 return getRuleContexts(DdContext.class); 1713 } 1714 public DdContext dd(int i) { 1715 return getRuleContext(DdContext.class,i); 1716 } 1717 public List<DtContext> dt() { 1718 return getRuleContexts(DtContext.class); 1719 } 1720 public DtContext dt(int i) { 1721 return getRuleContext(DtContext.class,i); 1722 } 1723 public List<HeadContext> head() { 1724 return getRuleContexts(HeadContext.class); 1725 } 1726 public HeadContext head(int i) { 1727 return getRuleContext(HeadContext.class,i); 1728 } 1729 public List<HtmlContext> html() { 1730 return getRuleContexts(HtmlContext.class); 1731 } 1732 public HtmlContext html(int i) { 1733 return getRuleContext(HtmlContext.class,i); 1734 } 1735 public List<OptionContext> option() { 1736 return getRuleContexts(OptionContext.class); 1737 } 1738 public OptionContext option(int i) { 1739 return getRuleContext(OptionContext.class,i); 1740 } 1741 public List<TbodyContext> tbody() { 1742 return getRuleContexts(TbodyContext.class); 1743 } 1744 public TbodyContext tbody(int i) { 1745 return getRuleContext(TbodyContext.class,i); 1746 } 1747 public List<TheadContext> thead() { 1748 return getRuleContexts(TheadContext.class); 1749 } 1750 public TheadContext thead(int i) { 1751 return getRuleContext(TheadContext.class,i); 1752 } 1753 public List<TfootContext> tfoot() { 1754 return getRuleContexts(TfootContext.class); 1755 } 1756 public TfootContext tfoot(int i) { 1757 return getRuleContext(TfootContext.class,i); 1758 } 1759 public List<LiTagOpenContext> liTagOpen() { 1760 return getRuleContexts(LiTagOpenContext.class); 1761 } 1762 public LiTagOpenContext liTagOpen(int i) { 1763 return getRuleContext(LiTagOpenContext.class,i); 1764 } 1765 public List<TrTagOpenContext> trTagOpen() { 1766 return getRuleContexts(TrTagOpenContext.class); 1767 } 1768 public TrTagOpenContext trTagOpen(int i) { 1769 return getRuleContext(TrTagOpenContext.class,i); 1770 } 1771 public List<TdTagOpenContext> tdTagOpen() { 1772 return getRuleContexts(TdTagOpenContext.class); 1773 } 1774 public TdTagOpenContext tdTagOpen(int i) { 1775 return getRuleContext(TdTagOpenContext.class,i); 1776 } 1777 public List<ThTagOpenContext> thTagOpen() { 1778 return getRuleContexts(ThTagOpenContext.class); 1779 } 1780 public ThTagOpenContext thTagOpen(int i) { 1781 return getRuleContext(ThTagOpenContext.class,i); 1782 } 1783 public List<BodyTagOpenContext> bodyTagOpen() { 1784 return getRuleContexts(BodyTagOpenContext.class); 1785 } 1786 public BodyTagOpenContext bodyTagOpen(int i) { 1787 return getRuleContext(BodyTagOpenContext.class,i); 1788 } 1789 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1790 return getRuleContexts(ColgroupTagOpenContext.class); 1791 } 1792 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1793 return getRuleContext(ColgroupTagOpenContext.class,i); 1794 } 1795 public List<DdTagOpenContext> ddTagOpen() { 1796 return getRuleContexts(DdTagOpenContext.class); 1797 } 1798 public DdTagOpenContext ddTagOpen(int i) { 1799 return getRuleContext(DdTagOpenContext.class,i); 1800 } 1801 public List<DtTagOpenContext> dtTagOpen() { 1802 return getRuleContexts(DtTagOpenContext.class); 1803 } 1804 public DtTagOpenContext dtTagOpen(int i) { 1805 return getRuleContext(DtTagOpenContext.class,i); 1806 } 1807 public List<HeadTagOpenContext> headTagOpen() { 1808 return getRuleContexts(HeadTagOpenContext.class); 1809 } 1810 public HeadTagOpenContext headTagOpen(int i) { 1811 return getRuleContext(HeadTagOpenContext.class,i); 1812 } 1813 public List<HtmlTagOpenContext> htmlTagOpen() { 1814 return getRuleContexts(HtmlTagOpenContext.class); 1815 } 1816 public HtmlTagOpenContext htmlTagOpen(int i) { 1817 return getRuleContext(HtmlTagOpenContext.class,i); 1818 } 1819 public List<OptionTagOpenContext> optionTagOpen() { 1820 return getRuleContexts(OptionTagOpenContext.class); 1821 } 1822 public OptionTagOpenContext optionTagOpen(int i) { 1823 return getRuleContext(OptionTagOpenContext.class,i); 1824 } 1825 public List<TbodyTagOpenContext> tbodyTagOpen() { 1826 return getRuleContexts(TbodyTagOpenContext.class); 1827 } 1828 public TbodyTagOpenContext tbodyTagOpen(int i) { 1829 return getRuleContext(TbodyTagOpenContext.class,i); 1830 } 1831 public List<TheadTagOpenContext> theadTagOpen() { 1832 return getRuleContexts(TheadTagOpenContext.class); 1833 } 1834 public TheadTagOpenContext theadTagOpen(int i) { 1835 return getRuleContext(TheadTagOpenContext.class,i); 1836 } 1837 public List<TfootTagOpenContext> tfootTagOpen() { 1838 return getRuleContexts(TfootTagOpenContext.class); 1839 } 1840 public TfootTagOpenContext tfootTagOpen(int i) { 1841 return getRuleContext(TfootTagOpenContext.class,i); 1842 } 1843 public List<HtmlCommentContext> htmlComment() { 1844 return getRuleContexts(HtmlCommentContext.class); 1845 } 1846 public HtmlCommentContext htmlComment(int i) { 1847 return getRuleContext(HtmlCommentContext.class,i); 1848 } 1849 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1850 public TerminalNode CDATA(int i) { 1851 return getToken(JavadocParser.CDATA, i); 1852 } 1853 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1854 public TerminalNode NEWLINE(int i) { 1855 return getToken(JavadocParser.NEWLINE, i); 1856 } 1857 public List<TextContext> text() { 1858 return getRuleContexts(TextContext.class); 1859 } 1860 public TextContext text(int i) { 1861 return getRuleContext(TextContext.class,i); 1862 } 1863 public List<JavadocInlineTagContext> javadocInlineTag() { 1864 return getRuleContexts(JavadocInlineTagContext.class); 1865 } 1866 public JavadocInlineTagContext javadocInlineTag(int i) { 1867 return getRuleContext(JavadocInlineTagContext.class,i); 1868 } 1869 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1870 public TerminalNode LEADING_ASTERISK(int i) { 1871 return getToken(JavadocParser.LEADING_ASTERISK, i); 1872 } 1873 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1874 super(parent, invokingState); 1875 } 1876 @Override public int getRuleIndex() { return RULE_paragraph; } 1877 @Override 1878 public void enterRule(ParseTreeListener listener) { 1879 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1880 } 1881 @Override 1882 public void exitRule(ParseTreeListener listener) { 1883 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1884 } 1885 @Override 1886 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1887 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1888 else return visitor.visitChildren(this); 1889 } 1890 } 1891 1892 public final ParagraphContext paragraph() throws RecognitionException { 1893 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1894 enterRule(_localctx, 16, RULE_paragraph); 1895 try { 1896 int _alt; 1897 enterOuterAlt(_localctx, 1); 1898 { 1899 setState(330); 1900 pTagOpen(); 1901 setState(370); 1902 _errHandler.sync(this); 1903 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1904 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1905 if ( _alt==1 ) { 1906 { 1907 setState(368); 1908 _errHandler.sync(this); 1909 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1910 case 1: 1911 { 1912 setState(331); 1913 htmlTag(); 1914 } 1915 break; 1916 case 2: 1917 { 1918 setState(332); 1919 singletonTag(); 1920 } 1921 break; 1922 case 3: 1923 { 1924 setState(333); 1925 li(); 1926 } 1927 break; 1928 case 4: 1929 { 1930 setState(334); 1931 tr(); 1932 } 1933 break; 1934 case 5: 1935 { 1936 setState(335); 1937 td(); 1938 } 1939 break; 1940 case 6: 1941 { 1942 setState(336); 1943 th(); 1944 } 1945 break; 1946 case 7: 1947 { 1948 setState(337); 1949 body(); 1950 } 1951 break; 1952 case 8: 1953 { 1954 setState(338); 1955 colgroup(); 1956 } 1957 break; 1958 case 9: 1959 { 1960 setState(339); 1961 dd(); 1962 } 1963 break; 1964 case 10: 1965 { 1966 setState(340); 1967 dt(); 1968 } 1969 break; 1970 case 11: 1971 { 1972 setState(341); 1973 head(); 1974 } 1975 break; 1976 case 12: 1977 { 1978 setState(342); 1979 html(); 1980 } 1981 break; 1982 case 13: 1983 { 1984 setState(343); 1985 option(); 1986 } 1987 break; 1988 case 14: 1989 { 1990 setState(344); 1991 tbody(); 1992 } 1993 break; 1994 case 15: 1995 { 1996 setState(345); 1997 thead(); 1998 } 1999 break; 2000 case 16: 2001 { 2002 setState(346); 2003 tfoot(); 2004 } 2005 break; 2006 case 17: 2007 { 2008 setState(347); 2009 liTagOpen(); 2010 } 2011 break; 2012 case 18: 2013 { 2014 setState(348); 2015 trTagOpen(); 2016 } 2017 break; 2018 case 19: 2019 { 2020 setState(349); 2021 tdTagOpen(); 2022 } 2023 break; 2024 case 20: 2025 { 2026 setState(350); 2027 thTagOpen(); 2028 } 2029 break; 2030 case 21: 2031 { 2032 setState(351); 2033 bodyTagOpen(); 2034 } 2035 break; 2036 case 22: 2037 { 2038 setState(352); 2039 colgroupTagOpen(); 2040 } 2041 break; 2042 case 23: 2043 { 2044 setState(353); 2045 ddTagOpen(); 2046 } 2047 break; 2048 case 24: 2049 { 2050 setState(354); 2051 dtTagOpen(); 2052 } 2053 break; 2054 case 25: 2055 { 2056 setState(355); 2057 headTagOpen(); 2058 } 2059 break; 2060 case 26: 2061 { 2062 setState(356); 2063 htmlTagOpen(); 2064 } 2065 break; 2066 case 27: 2067 { 2068 setState(357); 2069 optionTagOpen(); 2070 } 2071 break; 2072 case 28: 2073 { 2074 setState(358); 2075 tbodyTagOpen(); 2076 } 2077 break; 2078 case 29: 2079 { 2080 setState(359); 2081 theadTagOpen(); 2082 } 2083 break; 2084 case 30: 2085 { 2086 setState(360); 2087 tfootTagOpen(); 2088 } 2089 break; 2090 case 31: 2091 { 2092 { 2093 setState(361); 2094 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2095 setState(362); 2096 match(LEADING_ASTERISK); 2097 } 2098 } 2099 break; 2100 case 32: 2101 { 2102 setState(363); 2103 htmlComment(); 2104 } 2105 break; 2106 case 33: 2107 { 2108 setState(364); 2109 match(CDATA); 2110 } 2111 break; 2112 case 34: 2113 { 2114 setState(365); 2115 match(NEWLINE); 2116 } 2117 break; 2118 case 35: 2119 { 2120 setState(366); 2121 text(); 2122 } 2123 break; 2124 case 36: 2125 { 2126 setState(367); 2127 javadocInlineTag(); 2128 } 2129 break; 2130 } 2131 } 2132 } 2133 setState(372); 2134 _errHandler.sync(this); 2135 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2136 } 2137 setState(373); 2138 pTagClose(); 2139 } 2140 } 2141 catch (RecognitionException re) { 2142 _localctx.exception = re; 2143 _errHandler.reportError(this, re); 2144 _errHandler.recover(this, re); 2145 } 2146 finally { 2147 exitRule(); 2148 } 2149 return _localctx; 2150 } 2151 2152 public static class LiTagOpenContext extends ParserRuleContext { 2153 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2154 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2155 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2156 public List<AttributeContext> attribute() { 2157 return getRuleContexts(AttributeContext.class); 2158 } 2159 public AttributeContext attribute(int i) { 2160 return getRuleContext(AttributeContext.class,i); 2161 } 2162 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2163 public TerminalNode NEWLINE(int i) { 2164 return getToken(JavadocParser.NEWLINE, i); 2165 } 2166 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2167 public TerminalNode LEADING_ASTERISK(int i) { 2168 return getToken(JavadocParser.LEADING_ASTERISK, i); 2169 } 2170 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2171 public TerminalNode WS(int i) { 2172 return getToken(JavadocParser.WS, i); 2173 } 2174 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2175 super(parent, invokingState); 2176 } 2177 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2178 @Override 2179 public void enterRule(ParseTreeListener listener) { 2180 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2181 } 2182 @Override 2183 public void exitRule(ParseTreeListener listener) { 2184 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2185 } 2186 @Override 2187 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2188 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2189 else return visitor.visitChildren(this); 2190 } 2191 } 2192 2193 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2194 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2195 enterRule(_localctx, 18, RULE_liTagOpen); 2196 int _la; 2197 try { 2198 enterOuterAlt(_localctx, 1); 2199 { 2200 setState(375); 2201 match(OPEN); 2202 setState(376); 2203 match(LI_HTML_TAG_NAME); 2204 setState(383); 2205 _errHandler.sync(this); 2206 _la = _input.LA(1); 2207 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2208 { 2209 setState(381); 2210 _errHandler.sync(this); 2211 switch (_input.LA(1)) { 2212 case HTML_TAG_NAME: 2213 { 2214 setState(377); 2215 attribute(); 2216 } 2217 break; 2218 case NEWLINE: 2219 { 2220 setState(378); 2221 match(NEWLINE); 2222 } 2223 break; 2224 case LEADING_ASTERISK: 2225 { 2226 setState(379); 2227 match(LEADING_ASTERISK); 2228 } 2229 break; 2230 case WS: 2231 { 2232 setState(380); 2233 match(WS); 2234 } 2235 break; 2236 default: 2237 throw new NoViableAltException(this); 2238 } 2239 } 2240 setState(385); 2241 _errHandler.sync(this); 2242 _la = _input.LA(1); 2243 } 2244 setState(386); 2245 match(CLOSE); 2246 } 2247 } 2248 catch (RecognitionException re) { 2249 _localctx.exception = re; 2250 _errHandler.reportError(this, re); 2251 _errHandler.recover(this, re); 2252 } 2253 finally { 2254 exitRule(); 2255 } 2256 return _localctx; 2257 } 2258 2259 public static class LiTagCloseContext extends ParserRuleContext { 2260 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2261 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2262 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2263 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2264 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2265 public TerminalNode NEWLINE(int i) { 2266 return getToken(JavadocParser.NEWLINE, i); 2267 } 2268 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2269 public TerminalNode LEADING_ASTERISK(int i) { 2270 return getToken(JavadocParser.LEADING_ASTERISK, i); 2271 } 2272 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2273 public TerminalNode WS(int i) { 2274 return getToken(JavadocParser.WS, i); 2275 } 2276 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2277 super(parent, invokingState); 2278 } 2279 @Override public int getRuleIndex() { return RULE_liTagClose; } 2280 @Override 2281 public void enterRule(ParseTreeListener listener) { 2282 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2283 } 2284 @Override 2285 public void exitRule(ParseTreeListener listener) { 2286 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2287 } 2288 @Override 2289 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2290 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2291 else return visitor.visitChildren(this); 2292 } 2293 } 2294 2295 public final LiTagCloseContext liTagClose() throws RecognitionException { 2296 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2297 enterRule(_localctx, 20, RULE_liTagClose); 2298 int _la; 2299 try { 2300 enterOuterAlt(_localctx, 1); 2301 { 2302 setState(388); 2303 match(OPEN); 2304 setState(389); 2305 match(SLASH); 2306 setState(390); 2307 match(LI_HTML_TAG_NAME); 2308 setState(394); 2309 _errHandler.sync(this); 2310 _la = _input.LA(1); 2311 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2312 { 2313 { 2314 setState(391); 2315 _la = _input.LA(1); 2316 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2317 _errHandler.recoverInline(this); 2318 } 2319 else { 2320 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2321 _errHandler.reportMatch(this); 2322 consume(); 2323 } 2324 } 2325 } 2326 setState(396); 2327 _errHandler.sync(this); 2328 _la = _input.LA(1); 2329 } 2330 setState(397); 2331 match(CLOSE); 2332 } 2333 } 2334 catch (RecognitionException re) { 2335 _localctx.exception = re; 2336 _errHandler.reportError(this, re); 2337 _errHandler.recover(this, re); 2338 } 2339 finally { 2340 exitRule(); 2341 } 2342 return _localctx; 2343 } 2344 2345 public static class LiContext extends ParserRuleContext { 2346 public LiTagOpenContext liTagOpen() { 2347 return getRuleContext(LiTagOpenContext.class,0); 2348 } 2349 public LiTagCloseContext liTagClose() { 2350 return getRuleContext(LiTagCloseContext.class,0); 2351 } 2352 public List<HtmlTagContext> htmlTag() { 2353 return getRuleContexts(HtmlTagContext.class); 2354 } 2355 public HtmlTagContext htmlTag(int i) { 2356 return getRuleContext(HtmlTagContext.class,i); 2357 } 2358 public List<SingletonTagContext> singletonTag() { 2359 return getRuleContexts(SingletonTagContext.class); 2360 } 2361 public SingletonTagContext singletonTag(int i) { 2362 return getRuleContext(SingletonTagContext.class,i); 2363 } 2364 public List<ParagraphContext> paragraph() { 2365 return getRuleContexts(ParagraphContext.class); 2366 } 2367 public ParagraphContext paragraph(int i) { 2368 return getRuleContext(ParagraphContext.class,i); 2369 } 2370 public List<TrContext> tr() { 2371 return getRuleContexts(TrContext.class); 2372 } 2373 public TrContext tr(int i) { 2374 return getRuleContext(TrContext.class,i); 2375 } 2376 public List<TdContext> td() { 2377 return getRuleContexts(TdContext.class); 2378 } 2379 public TdContext td(int i) { 2380 return getRuleContext(TdContext.class,i); 2381 } 2382 public List<ThContext> th() { 2383 return getRuleContexts(ThContext.class); 2384 } 2385 public ThContext th(int i) { 2386 return getRuleContext(ThContext.class,i); 2387 } 2388 public List<BodyContext> body() { 2389 return getRuleContexts(BodyContext.class); 2390 } 2391 public BodyContext body(int i) { 2392 return getRuleContext(BodyContext.class,i); 2393 } 2394 public List<ColgroupContext> colgroup() { 2395 return getRuleContexts(ColgroupContext.class); 2396 } 2397 public ColgroupContext colgroup(int i) { 2398 return getRuleContext(ColgroupContext.class,i); 2399 } 2400 public List<DdContext> dd() { 2401 return getRuleContexts(DdContext.class); 2402 } 2403 public DdContext dd(int i) { 2404 return getRuleContext(DdContext.class,i); 2405 } 2406 public List<DtContext> dt() { 2407 return getRuleContexts(DtContext.class); 2408 } 2409 public DtContext dt(int i) { 2410 return getRuleContext(DtContext.class,i); 2411 } 2412 public List<HeadContext> head() { 2413 return getRuleContexts(HeadContext.class); 2414 } 2415 public HeadContext head(int i) { 2416 return getRuleContext(HeadContext.class,i); 2417 } 2418 public List<HtmlContext> html() { 2419 return getRuleContexts(HtmlContext.class); 2420 } 2421 public HtmlContext html(int i) { 2422 return getRuleContext(HtmlContext.class,i); 2423 } 2424 public List<OptionContext> option() { 2425 return getRuleContexts(OptionContext.class); 2426 } 2427 public OptionContext option(int i) { 2428 return getRuleContext(OptionContext.class,i); 2429 } 2430 public List<TbodyContext> tbody() { 2431 return getRuleContexts(TbodyContext.class); 2432 } 2433 public TbodyContext tbody(int i) { 2434 return getRuleContext(TbodyContext.class,i); 2435 } 2436 public List<TheadContext> thead() { 2437 return getRuleContexts(TheadContext.class); 2438 } 2439 public TheadContext thead(int i) { 2440 return getRuleContext(TheadContext.class,i); 2441 } 2442 public List<TfootContext> tfoot() { 2443 return getRuleContexts(TfootContext.class); 2444 } 2445 public TfootContext tfoot(int i) { 2446 return getRuleContext(TfootContext.class,i); 2447 } 2448 public List<PTagOpenContext> pTagOpen() { 2449 return getRuleContexts(PTagOpenContext.class); 2450 } 2451 public PTagOpenContext pTagOpen(int i) { 2452 return getRuleContext(PTagOpenContext.class,i); 2453 } 2454 public List<TrTagOpenContext> trTagOpen() { 2455 return getRuleContexts(TrTagOpenContext.class); 2456 } 2457 public TrTagOpenContext trTagOpen(int i) { 2458 return getRuleContext(TrTagOpenContext.class,i); 2459 } 2460 public List<TdTagOpenContext> tdTagOpen() { 2461 return getRuleContexts(TdTagOpenContext.class); 2462 } 2463 public TdTagOpenContext tdTagOpen(int i) { 2464 return getRuleContext(TdTagOpenContext.class,i); 2465 } 2466 public List<ThTagOpenContext> thTagOpen() { 2467 return getRuleContexts(ThTagOpenContext.class); 2468 } 2469 public ThTagOpenContext thTagOpen(int i) { 2470 return getRuleContext(ThTagOpenContext.class,i); 2471 } 2472 public List<BodyTagOpenContext> bodyTagOpen() { 2473 return getRuleContexts(BodyTagOpenContext.class); 2474 } 2475 public BodyTagOpenContext bodyTagOpen(int i) { 2476 return getRuleContext(BodyTagOpenContext.class,i); 2477 } 2478 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2479 return getRuleContexts(ColgroupTagOpenContext.class); 2480 } 2481 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2482 return getRuleContext(ColgroupTagOpenContext.class,i); 2483 } 2484 public List<DdTagOpenContext> ddTagOpen() { 2485 return getRuleContexts(DdTagOpenContext.class); 2486 } 2487 public DdTagOpenContext ddTagOpen(int i) { 2488 return getRuleContext(DdTagOpenContext.class,i); 2489 } 2490 public List<DtTagOpenContext> dtTagOpen() { 2491 return getRuleContexts(DtTagOpenContext.class); 2492 } 2493 public DtTagOpenContext dtTagOpen(int i) { 2494 return getRuleContext(DtTagOpenContext.class,i); 2495 } 2496 public List<HeadTagOpenContext> headTagOpen() { 2497 return getRuleContexts(HeadTagOpenContext.class); 2498 } 2499 public HeadTagOpenContext headTagOpen(int i) { 2500 return getRuleContext(HeadTagOpenContext.class,i); 2501 } 2502 public List<HtmlTagOpenContext> htmlTagOpen() { 2503 return getRuleContexts(HtmlTagOpenContext.class); 2504 } 2505 public HtmlTagOpenContext htmlTagOpen(int i) { 2506 return getRuleContext(HtmlTagOpenContext.class,i); 2507 } 2508 public List<OptionTagOpenContext> optionTagOpen() { 2509 return getRuleContexts(OptionTagOpenContext.class); 2510 } 2511 public OptionTagOpenContext optionTagOpen(int i) { 2512 return getRuleContext(OptionTagOpenContext.class,i); 2513 } 2514 public List<TbodyTagOpenContext> tbodyTagOpen() { 2515 return getRuleContexts(TbodyTagOpenContext.class); 2516 } 2517 public TbodyTagOpenContext tbodyTagOpen(int i) { 2518 return getRuleContext(TbodyTagOpenContext.class,i); 2519 } 2520 public List<TheadTagOpenContext> theadTagOpen() { 2521 return getRuleContexts(TheadTagOpenContext.class); 2522 } 2523 public TheadTagOpenContext theadTagOpen(int i) { 2524 return getRuleContext(TheadTagOpenContext.class,i); 2525 } 2526 public List<TfootTagOpenContext> tfootTagOpen() { 2527 return getRuleContexts(TfootTagOpenContext.class); 2528 } 2529 public TfootTagOpenContext tfootTagOpen(int i) { 2530 return getRuleContext(TfootTagOpenContext.class,i); 2531 } 2532 public List<HtmlCommentContext> htmlComment() { 2533 return getRuleContexts(HtmlCommentContext.class); 2534 } 2535 public HtmlCommentContext htmlComment(int i) { 2536 return getRuleContext(HtmlCommentContext.class,i); 2537 } 2538 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2539 public TerminalNode CDATA(int i) { 2540 return getToken(JavadocParser.CDATA, i); 2541 } 2542 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2543 public TerminalNode NEWLINE(int i) { 2544 return getToken(JavadocParser.NEWLINE, i); 2545 } 2546 public List<TextContext> text() { 2547 return getRuleContexts(TextContext.class); 2548 } 2549 public TextContext text(int i) { 2550 return getRuleContext(TextContext.class,i); 2551 } 2552 public List<JavadocInlineTagContext> javadocInlineTag() { 2553 return getRuleContexts(JavadocInlineTagContext.class); 2554 } 2555 public JavadocInlineTagContext javadocInlineTag(int i) { 2556 return getRuleContext(JavadocInlineTagContext.class,i); 2557 } 2558 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2559 public TerminalNode LEADING_ASTERISK(int i) { 2560 return getToken(JavadocParser.LEADING_ASTERISK, i); 2561 } 2562 public LiContext(ParserRuleContext parent, int invokingState) { 2563 super(parent, invokingState); 2564 } 2565 @Override public int getRuleIndex() { return RULE_li; } 2566 @Override 2567 public void enterRule(ParseTreeListener listener) { 2568 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2569 } 2570 @Override 2571 public void exitRule(ParseTreeListener listener) { 2572 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2573 } 2574 @Override 2575 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2576 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2577 else return visitor.visitChildren(this); 2578 } 2579 } 2580 2581 public final LiContext li() throws RecognitionException { 2582 LiContext _localctx = new LiContext(_ctx, getState()); 2583 enterRule(_localctx, 22, RULE_li); 2584 try { 2585 int _alt; 2586 enterOuterAlt(_localctx, 1); 2587 { 2588 setState(399); 2589 liTagOpen(); 2590 setState(439); 2591 _errHandler.sync(this); 2592 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2593 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2594 if ( _alt==1 ) { 2595 { 2596 setState(437); 2597 _errHandler.sync(this); 2598 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2599 case 1: 2600 { 2601 setState(400); 2602 htmlTag(); 2603 } 2604 break; 2605 case 2: 2606 { 2607 setState(401); 2608 singletonTag(); 2609 } 2610 break; 2611 case 3: 2612 { 2613 setState(402); 2614 paragraph(); 2615 } 2616 break; 2617 case 4: 2618 { 2619 setState(403); 2620 tr(); 2621 } 2622 break; 2623 case 5: 2624 { 2625 setState(404); 2626 td(); 2627 } 2628 break; 2629 case 6: 2630 { 2631 setState(405); 2632 th(); 2633 } 2634 break; 2635 case 7: 2636 { 2637 setState(406); 2638 body(); 2639 } 2640 break; 2641 case 8: 2642 { 2643 setState(407); 2644 colgroup(); 2645 } 2646 break; 2647 case 9: 2648 { 2649 setState(408); 2650 dd(); 2651 } 2652 break; 2653 case 10: 2654 { 2655 setState(409); 2656 dt(); 2657 } 2658 break; 2659 case 11: 2660 { 2661 setState(410); 2662 head(); 2663 } 2664 break; 2665 case 12: 2666 { 2667 setState(411); 2668 html(); 2669 } 2670 break; 2671 case 13: 2672 { 2673 setState(412); 2674 option(); 2675 } 2676 break; 2677 case 14: 2678 { 2679 setState(413); 2680 tbody(); 2681 } 2682 break; 2683 case 15: 2684 { 2685 setState(414); 2686 thead(); 2687 } 2688 break; 2689 case 16: 2690 { 2691 setState(415); 2692 tfoot(); 2693 } 2694 break; 2695 case 17: 2696 { 2697 setState(416); 2698 pTagOpen(); 2699 } 2700 break; 2701 case 18: 2702 { 2703 setState(417); 2704 trTagOpen(); 2705 } 2706 break; 2707 case 19: 2708 { 2709 setState(418); 2710 tdTagOpen(); 2711 } 2712 break; 2713 case 20: 2714 { 2715 setState(419); 2716 thTagOpen(); 2717 } 2718 break; 2719 case 21: 2720 { 2721 setState(420); 2722 bodyTagOpen(); 2723 } 2724 break; 2725 case 22: 2726 { 2727 setState(421); 2728 colgroupTagOpen(); 2729 } 2730 break; 2731 case 23: 2732 { 2733 setState(422); 2734 ddTagOpen(); 2735 } 2736 break; 2737 case 24: 2738 { 2739 setState(423); 2740 dtTagOpen(); 2741 } 2742 break; 2743 case 25: 2744 { 2745 setState(424); 2746 headTagOpen(); 2747 } 2748 break; 2749 case 26: 2750 { 2751 setState(425); 2752 htmlTagOpen(); 2753 } 2754 break; 2755 case 27: 2756 { 2757 setState(426); 2758 optionTagOpen(); 2759 } 2760 break; 2761 case 28: 2762 { 2763 setState(427); 2764 tbodyTagOpen(); 2765 } 2766 break; 2767 case 29: 2768 { 2769 setState(428); 2770 theadTagOpen(); 2771 } 2772 break; 2773 case 30: 2774 { 2775 setState(429); 2776 tfootTagOpen(); 2777 } 2778 break; 2779 case 31: 2780 { 2781 { 2782 setState(430); 2783 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2784 setState(431); 2785 match(LEADING_ASTERISK); 2786 } 2787 } 2788 break; 2789 case 32: 2790 { 2791 setState(432); 2792 htmlComment(); 2793 } 2794 break; 2795 case 33: 2796 { 2797 setState(433); 2798 match(CDATA); 2799 } 2800 break; 2801 case 34: 2802 { 2803 setState(434); 2804 match(NEWLINE); 2805 } 2806 break; 2807 case 35: 2808 { 2809 setState(435); 2810 text(); 2811 } 2812 break; 2813 case 36: 2814 { 2815 setState(436); 2816 javadocInlineTag(); 2817 } 2818 break; 2819 } 2820 } 2821 } 2822 setState(441); 2823 _errHandler.sync(this); 2824 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2825 } 2826 setState(442); 2827 liTagClose(); 2828 } 2829 } 2830 catch (RecognitionException re) { 2831 _localctx.exception = re; 2832 _errHandler.reportError(this, re); 2833 _errHandler.recover(this, re); 2834 } 2835 finally { 2836 exitRule(); 2837 } 2838 return _localctx; 2839 } 2840 2841 public static class TrTagOpenContext extends ParserRuleContext { 2842 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2843 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2844 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2845 public List<AttributeContext> attribute() { 2846 return getRuleContexts(AttributeContext.class); 2847 } 2848 public AttributeContext attribute(int i) { 2849 return getRuleContext(AttributeContext.class,i); 2850 } 2851 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2852 public TerminalNode NEWLINE(int i) { 2853 return getToken(JavadocParser.NEWLINE, i); 2854 } 2855 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2856 public TerminalNode LEADING_ASTERISK(int i) { 2857 return getToken(JavadocParser.LEADING_ASTERISK, i); 2858 } 2859 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2860 public TerminalNode WS(int i) { 2861 return getToken(JavadocParser.WS, i); 2862 } 2863 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2864 super(parent, invokingState); 2865 } 2866 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2867 @Override 2868 public void enterRule(ParseTreeListener listener) { 2869 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2870 } 2871 @Override 2872 public void exitRule(ParseTreeListener listener) { 2873 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2874 } 2875 @Override 2876 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2877 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2878 else return visitor.visitChildren(this); 2879 } 2880 } 2881 2882 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2883 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2884 enterRule(_localctx, 24, RULE_trTagOpen); 2885 int _la; 2886 try { 2887 enterOuterAlt(_localctx, 1); 2888 { 2889 setState(444); 2890 match(OPEN); 2891 setState(445); 2892 match(TR_HTML_TAG_NAME); 2893 setState(452); 2894 _errHandler.sync(this); 2895 _la = _input.LA(1); 2896 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2897 { 2898 setState(450); 2899 _errHandler.sync(this); 2900 switch (_input.LA(1)) { 2901 case HTML_TAG_NAME: 2902 { 2903 setState(446); 2904 attribute(); 2905 } 2906 break; 2907 case NEWLINE: 2908 { 2909 setState(447); 2910 match(NEWLINE); 2911 } 2912 break; 2913 case LEADING_ASTERISK: 2914 { 2915 setState(448); 2916 match(LEADING_ASTERISK); 2917 } 2918 break; 2919 case WS: 2920 { 2921 setState(449); 2922 match(WS); 2923 } 2924 break; 2925 default: 2926 throw new NoViableAltException(this); 2927 } 2928 } 2929 setState(454); 2930 _errHandler.sync(this); 2931 _la = _input.LA(1); 2932 } 2933 setState(455); 2934 match(CLOSE); 2935 } 2936 } 2937 catch (RecognitionException re) { 2938 _localctx.exception = re; 2939 _errHandler.reportError(this, re); 2940 _errHandler.recover(this, re); 2941 } 2942 finally { 2943 exitRule(); 2944 } 2945 return _localctx; 2946 } 2947 2948 public static class TrTagCloseContext extends ParserRuleContext { 2949 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2950 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2951 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2952 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2953 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2954 public TerminalNode NEWLINE(int i) { 2955 return getToken(JavadocParser.NEWLINE, i); 2956 } 2957 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2958 public TerminalNode LEADING_ASTERISK(int i) { 2959 return getToken(JavadocParser.LEADING_ASTERISK, i); 2960 } 2961 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2962 public TerminalNode WS(int i) { 2963 return getToken(JavadocParser.WS, i); 2964 } 2965 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2966 super(parent, invokingState); 2967 } 2968 @Override public int getRuleIndex() { return RULE_trTagClose; } 2969 @Override 2970 public void enterRule(ParseTreeListener listener) { 2971 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2972 } 2973 @Override 2974 public void exitRule(ParseTreeListener listener) { 2975 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2976 } 2977 @Override 2978 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2979 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2980 else return visitor.visitChildren(this); 2981 } 2982 } 2983 2984 public final TrTagCloseContext trTagClose() throws RecognitionException { 2985 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2986 enterRule(_localctx, 26, RULE_trTagClose); 2987 int _la; 2988 try { 2989 enterOuterAlt(_localctx, 1); 2990 { 2991 setState(457); 2992 match(OPEN); 2993 setState(458); 2994 match(SLASH); 2995 setState(459); 2996 match(TR_HTML_TAG_NAME); 2997 setState(463); 2998 _errHandler.sync(this); 2999 _la = _input.LA(1); 3000 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3001 { 3002 { 3003 setState(460); 3004 _la = _input.LA(1); 3005 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3006 _errHandler.recoverInline(this); 3007 } 3008 else { 3009 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3010 _errHandler.reportMatch(this); 3011 consume(); 3012 } 3013 } 3014 } 3015 setState(465); 3016 _errHandler.sync(this); 3017 _la = _input.LA(1); 3018 } 3019 setState(466); 3020 match(CLOSE); 3021 } 3022 } 3023 catch (RecognitionException re) { 3024 _localctx.exception = re; 3025 _errHandler.reportError(this, re); 3026 _errHandler.recover(this, re); 3027 } 3028 finally { 3029 exitRule(); 3030 } 3031 return _localctx; 3032 } 3033 3034 public static class TrContext extends ParserRuleContext { 3035 public TrTagOpenContext trTagOpen() { 3036 return getRuleContext(TrTagOpenContext.class,0); 3037 } 3038 public TrTagCloseContext trTagClose() { 3039 return getRuleContext(TrTagCloseContext.class,0); 3040 } 3041 public List<HtmlTagContext> htmlTag() { 3042 return getRuleContexts(HtmlTagContext.class); 3043 } 3044 public HtmlTagContext htmlTag(int i) { 3045 return getRuleContext(HtmlTagContext.class,i); 3046 } 3047 public List<SingletonTagContext> singletonTag() { 3048 return getRuleContexts(SingletonTagContext.class); 3049 } 3050 public SingletonTagContext singletonTag(int i) { 3051 return getRuleContext(SingletonTagContext.class,i); 3052 } 3053 public List<ParagraphContext> paragraph() { 3054 return getRuleContexts(ParagraphContext.class); 3055 } 3056 public ParagraphContext paragraph(int i) { 3057 return getRuleContext(ParagraphContext.class,i); 3058 } 3059 public List<LiContext> li() { 3060 return getRuleContexts(LiContext.class); 3061 } 3062 public LiContext li(int i) { 3063 return getRuleContext(LiContext.class,i); 3064 } 3065 public List<TdContext> td() { 3066 return getRuleContexts(TdContext.class); 3067 } 3068 public TdContext td(int i) { 3069 return getRuleContext(TdContext.class,i); 3070 } 3071 public List<ThContext> th() { 3072 return getRuleContexts(ThContext.class); 3073 } 3074 public ThContext th(int i) { 3075 return getRuleContext(ThContext.class,i); 3076 } 3077 public List<BodyContext> body() { 3078 return getRuleContexts(BodyContext.class); 3079 } 3080 public BodyContext body(int i) { 3081 return getRuleContext(BodyContext.class,i); 3082 } 3083 public List<ColgroupContext> colgroup() { 3084 return getRuleContexts(ColgroupContext.class); 3085 } 3086 public ColgroupContext colgroup(int i) { 3087 return getRuleContext(ColgroupContext.class,i); 3088 } 3089 public List<DdContext> dd() { 3090 return getRuleContexts(DdContext.class); 3091 } 3092 public DdContext dd(int i) { 3093 return getRuleContext(DdContext.class,i); 3094 } 3095 public List<DtContext> dt() { 3096 return getRuleContexts(DtContext.class); 3097 } 3098 public DtContext dt(int i) { 3099 return getRuleContext(DtContext.class,i); 3100 } 3101 public List<HeadContext> head() { 3102 return getRuleContexts(HeadContext.class); 3103 } 3104 public HeadContext head(int i) { 3105 return getRuleContext(HeadContext.class,i); 3106 } 3107 public List<HtmlContext> html() { 3108 return getRuleContexts(HtmlContext.class); 3109 } 3110 public HtmlContext html(int i) { 3111 return getRuleContext(HtmlContext.class,i); 3112 } 3113 public List<OptionContext> option() { 3114 return getRuleContexts(OptionContext.class); 3115 } 3116 public OptionContext option(int i) { 3117 return getRuleContext(OptionContext.class,i); 3118 } 3119 public List<TbodyContext> tbody() { 3120 return getRuleContexts(TbodyContext.class); 3121 } 3122 public TbodyContext tbody(int i) { 3123 return getRuleContext(TbodyContext.class,i); 3124 } 3125 public List<TheadContext> thead() { 3126 return getRuleContexts(TheadContext.class); 3127 } 3128 public TheadContext thead(int i) { 3129 return getRuleContext(TheadContext.class,i); 3130 } 3131 public List<TfootContext> tfoot() { 3132 return getRuleContexts(TfootContext.class); 3133 } 3134 public TfootContext tfoot(int i) { 3135 return getRuleContext(TfootContext.class,i); 3136 } 3137 public List<PTagOpenContext> pTagOpen() { 3138 return getRuleContexts(PTagOpenContext.class); 3139 } 3140 public PTagOpenContext pTagOpen(int i) { 3141 return getRuleContext(PTagOpenContext.class,i); 3142 } 3143 public List<LiTagOpenContext> liTagOpen() { 3144 return getRuleContexts(LiTagOpenContext.class); 3145 } 3146 public LiTagOpenContext liTagOpen(int i) { 3147 return getRuleContext(LiTagOpenContext.class,i); 3148 } 3149 public List<TdTagOpenContext> tdTagOpen() { 3150 return getRuleContexts(TdTagOpenContext.class); 3151 } 3152 public TdTagOpenContext tdTagOpen(int i) { 3153 return getRuleContext(TdTagOpenContext.class,i); 3154 } 3155 public List<ThTagOpenContext> thTagOpen() { 3156 return getRuleContexts(ThTagOpenContext.class); 3157 } 3158 public ThTagOpenContext thTagOpen(int i) { 3159 return getRuleContext(ThTagOpenContext.class,i); 3160 } 3161 public List<BodyTagOpenContext> bodyTagOpen() { 3162 return getRuleContexts(BodyTagOpenContext.class); 3163 } 3164 public BodyTagOpenContext bodyTagOpen(int i) { 3165 return getRuleContext(BodyTagOpenContext.class,i); 3166 } 3167 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3168 return getRuleContexts(ColgroupTagOpenContext.class); 3169 } 3170 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3171 return getRuleContext(ColgroupTagOpenContext.class,i); 3172 } 3173 public List<DdTagOpenContext> ddTagOpen() { 3174 return getRuleContexts(DdTagOpenContext.class); 3175 } 3176 public DdTagOpenContext ddTagOpen(int i) { 3177 return getRuleContext(DdTagOpenContext.class,i); 3178 } 3179 public List<DtTagOpenContext> dtTagOpen() { 3180 return getRuleContexts(DtTagOpenContext.class); 3181 } 3182 public DtTagOpenContext dtTagOpen(int i) { 3183 return getRuleContext(DtTagOpenContext.class,i); 3184 } 3185 public List<HeadTagOpenContext> headTagOpen() { 3186 return getRuleContexts(HeadTagOpenContext.class); 3187 } 3188 public HeadTagOpenContext headTagOpen(int i) { 3189 return getRuleContext(HeadTagOpenContext.class,i); 3190 } 3191 public List<HtmlTagOpenContext> htmlTagOpen() { 3192 return getRuleContexts(HtmlTagOpenContext.class); 3193 } 3194 public HtmlTagOpenContext htmlTagOpen(int i) { 3195 return getRuleContext(HtmlTagOpenContext.class,i); 3196 } 3197 public List<OptionTagOpenContext> optionTagOpen() { 3198 return getRuleContexts(OptionTagOpenContext.class); 3199 } 3200 public OptionTagOpenContext optionTagOpen(int i) { 3201 return getRuleContext(OptionTagOpenContext.class,i); 3202 } 3203 public List<TbodyTagOpenContext> tbodyTagOpen() { 3204 return getRuleContexts(TbodyTagOpenContext.class); 3205 } 3206 public TbodyTagOpenContext tbodyTagOpen(int i) { 3207 return getRuleContext(TbodyTagOpenContext.class,i); 3208 } 3209 public List<TheadTagOpenContext> theadTagOpen() { 3210 return getRuleContexts(TheadTagOpenContext.class); 3211 } 3212 public TheadTagOpenContext theadTagOpen(int i) { 3213 return getRuleContext(TheadTagOpenContext.class,i); 3214 } 3215 public List<TfootTagOpenContext> tfootTagOpen() { 3216 return getRuleContexts(TfootTagOpenContext.class); 3217 } 3218 public TfootTagOpenContext tfootTagOpen(int i) { 3219 return getRuleContext(TfootTagOpenContext.class,i); 3220 } 3221 public List<HtmlCommentContext> htmlComment() { 3222 return getRuleContexts(HtmlCommentContext.class); 3223 } 3224 public HtmlCommentContext htmlComment(int i) { 3225 return getRuleContext(HtmlCommentContext.class,i); 3226 } 3227 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3228 public TerminalNode CDATA(int i) { 3229 return getToken(JavadocParser.CDATA, i); 3230 } 3231 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3232 public TerminalNode NEWLINE(int i) { 3233 return getToken(JavadocParser.NEWLINE, i); 3234 } 3235 public List<TextContext> text() { 3236 return getRuleContexts(TextContext.class); 3237 } 3238 public TextContext text(int i) { 3239 return getRuleContext(TextContext.class,i); 3240 } 3241 public List<JavadocInlineTagContext> javadocInlineTag() { 3242 return getRuleContexts(JavadocInlineTagContext.class); 3243 } 3244 public JavadocInlineTagContext javadocInlineTag(int i) { 3245 return getRuleContext(JavadocInlineTagContext.class,i); 3246 } 3247 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3248 public TerminalNode LEADING_ASTERISK(int i) { 3249 return getToken(JavadocParser.LEADING_ASTERISK, i); 3250 } 3251 public TrContext(ParserRuleContext parent, int invokingState) { 3252 super(parent, invokingState); 3253 } 3254 @Override public int getRuleIndex() { return RULE_tr; } 3255 @Override 3256 public void enterRule(ParseTreeListener listener) { 3257 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3258 } 3259 @Override 3260 public void exitRule(ParseTreeListener listener) { 3261 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3262 } 3263 @Override 3264 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3265 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3266 else return visitor.visitChildren(this); 3267 } 3268 } 3269 3270 public final TrContext tr() throws RecognitionException { 3271 TrContext _localctx = new TrContext(_ctx, getState()); 3272 enterRule(_localctx, 28, RULE_tr); 3273 try { 3274 int _alt; 3275 enterOuterAlt(_localctx, 1); 3276 { 3277 setState(468); 3278 trTagOpen(); 3279 setState(508); 3280 _errHandler.sync(this); 3281 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3282 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3283 if ( _alt==1 ) { 3284 { 3285 setState(506); 3286 _errHandler.sync(this); 3287 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3288 case 1: 3289 { 3290 setState(469); 3291 htmlTag(); 3292 } 3293 break; 3294 case 2: 3295 { 3296 setState(470); 3297 singletonTag(); 3298 } 3299 break; 3300 case 3: 3301 { 3302 setState(471); 3303 paragraph(); 3304 } 3305 break; 3306 case 4: 3307 { 3308 setState(472); 3309 li(); 3310 } 3311 break; 3312 case 5: 3313 { 3314 setState(473); 3315 td(); 3316 } 3317 break; 3318 case 6: 3319 { 3320 setState(474); 3321 th(); 3322 } 3323 break; 3324 case 7: 3325 { 3326 setState(475); 3327 body(); 3328 } 3329 break; 3330 case 8: 3331 { 3332 setState(476); 3333 colgroup(); 3334 } 3335 break; 3336 case 9: 3337 { 3338 setState(477); 3339 dd(); 3340 } 3341 break; 3342 case 10: 3343 { 3344 setState(478); 3345 dt(); 3346 } 3347 break; 3348 case 11: 3349 { 3350 setState(479); 3351 head(); 3352 } 3353 break; 3354 case 12: 3355 { 3356 setState(480); 3357 html(); 3358 } 3359 break; 3360 case 13: 3361 { 3362 setState(481); 3363 option(); 3364 } 3365 break; 3366 case 14: 3367 { 3368 setState(482); 3369 tbody(); 3370 } 3371 break; 3372 case 15: 3373 { 3374 setState(483); 3375 thead(); 3376 } 3377 break; 3378 case 16: 3379 { 3380 setState(484); 3381 tfoot(); 3382 } 3383 break; 3384 case 17: 3385 { 3386 setState(485); 3387 pTagOpen(); 3388 } 3389 break; 3390 case 18: 3391 { 3392 setState(486); 3393 liTagOpen(); 3394 } 3395 break; 3396 case 19: 3397 { 3398 setState(487); 3399 tdTagOpen(); 3400 } 3401 break; 3402 case 20: 3403 { 3404 setState(488); 3405 thTagOpen(); 3406 } 3407 break; 3408 case 21: 3409 { 3410 setState(489); 3411 bodyTagOpen(); 3412 } 3413 break; 3414 case 22: 3415 { 3416 setState(490); 3417 colgroupTagOpen(); 3418 } 3419 break; 3420 case 23: 3421 { 3422 setState(491); 3423 ddTagOpen(); 3424 } 3425 break; 3426 case 24: 3427 { 3428 setState(492); 3429 dtTagOpen(); 3430 } 3431 break; 3432 case 25: 3433 { 3434 setState(493); 3435 headTagOpen(); 3436 } 3437 break; 3438 case 26: 3439 { 3440 setState(494); 3441 htmlTagOpen(); 3442 } 3443 break; 3444 case 27: 3445 { 3446 setState(495); 3447 optionTagOpen(); 3448 } 3449 break; 3450 case 28: 3451 { 3452 setState(496); 3453 tbodyTagOpen(); 3454 } 3455 break; 3456 case 29: 3457 { 3458 setState(497); 3459 theadTagOpen(); 3460 } 3461 break; 3462 case 30: 3463 { 3464 setState(498); 3465 tfootTagOpen(); 3466 } 3467 break; 3468 case 31: 3469 { 3470 { 3471 setState(499); 3472 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3473 setState(500); 3474 match(LEADING_ASTERISK); 3475 } 3476 } 3477 break; 3478 case 32: 3479 { 3480 setState(501); 3481 htmlComment(); 3482 } 3483 break; 3484 case 33: 3485 { 3486 setState(502); 3487 match(CDATA); 3488 } 3489 break; 3490 case 34: 3491 { 3492 setState(503); 3493 match(NEWLINE); 3494 } 3495 break; 3496 case 35: 3497 { 3498 setState(504); 3499 text(); 3500 } 3501 break; 3502 case 36: 3503 { 3504 setState(505); 3505 javadocInlineTag(); 3506 } 3507 break; 3508 } 3509 } 3510 } 3511 setState(510); 3512 _errHandler.sync(this); 3513 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3514 } 3515 setState(511); 3516 trTagClose(); 3517 } 3518 } 3519 catch (RecognitionException re) { 3520 _localctx.exception = re; 3521 _errHandler.reportError(this, re); 3522 _errHandler.recover(this, re); 3523 } 3524 finally { 3525 exitRule(); 3526 } 3527 return _localctx; 3528 } 3529 3530 public static class TdTagOpenContext extends ParserRuleContext { 3531 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3532 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3533 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3534 public List<AttributeContext> attribute() { 3535 return getRuleContexts(AttributeContext.class); 3536 } 3537 public AttributeContext attribute(int i) { 3538 return getRuleContext(AttributeContext.class,i); 3539 } 3540 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3541 public TerminalNode NEWLINE(int i) { 3542 return getToken(JavadocParser.NEWLINE, i); 3543 } 3544 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3545 public TerminalNode LEADING_ASTERISK(int i) { 3546 return getToken(JavadocParser.LEADING_ASTERISK, i); 3547 } 3548 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3549 public TerminalNode WS(int i) { 3550 return getToken(JavadocParser.WS, i); 3551 } 3552 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3553 super(parent, invokingState); 3554 } 3555 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3556 @Override 3557 public void enterRule(ParseTreeListener listener) { 3558 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3559 } 3560 @Override 3561 public void exitRule(ParseTreeListener listener) { 3562 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3563 } 3564 @Override 3565 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3566 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3567 else return visitor.visitChildren(this); 3568 } 3569 } 3570 3571 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3572 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3573 enterRule(_localctx, 30, RULE_tdTagOpen); 3574 int _la; 3575 try { 3576 enterOuterAlt(_localctx, 1); 3577 { 3578 setState(513); 3579 match(OPEN); 3580 setState(514); 3581 match(TD_HTML_TAG_NAME); 3582 setState(521); 3583 _errHandler.sync(this); 3584 _la = _input.LA(1); 3585 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3586 { 3587 setState(519); 3588 _errHandler.sync(this); 3589 switch (_input.LA(1)) { 3590 case HTML_TAG_NAME: 3591 { 3592 setState(515); 3593 attribute(); 3594 } 3595 break; 3596 case NEWLINE: 3597 { 3598 setState(516); 3599 match(NEWLINE); 3600 } 3601 break; 3602 case LEADING_ASTERISK: 3603 { 3604 setState(517); 3605 match(LEADING_ASTERISK); 3606 } 3607 break; 3608 case WS: 3609 { 3610 setState(518); 3611 match(WS); 3612 } 3613 break; 3614 default: 3615 throw new NoViableAltException(this); 3616 } 3617 } 3618 setState(523); 3619 _errHandler.sync(this); 3620 _la = _input.LA(1); 3621 } 3622 setState(524); 3623 match(CLOSE); 3624 } 3625 } 3626 catch (RecognitionException re) { 3627 _localctx.exception = re; 3628 _errHandler.reportError(this, re); 3629 _errHandler.recover(this, re); 3630 } 3631 finally { 3632 exitRule(); 3633 } 3634 return _localctx; 3635 } 3636 3637 public static class TdTagCloseContext extends ParserRuleContext { 3638 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3639 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3640 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3641 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3642 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3643 public TerminalNode NEWLINE(int i) { 3644 return getToken(JavadocParser.NEWLINE, i); 3645 } 3646 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3647 public TerminalNode LEADING_ASTERISK(int i) { 3648 return getToken(JavadocParser.LEADING_ASTERISK, i); 3649 } 3650 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3651 public TerminalNode WS(int i) { 3652 return getToken(JavadocParser.WS, i); 3653 } 3654 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3655 super(parent, invokingState); 3656 } 3657 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3658 @Override 3659 public void enterRule(ParseTreeListener listener) { 3660 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3661 } 3662 @Override 3663 public void exitRule(ParseTreeListener listener) { 3664 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3665 } 3666 @Override 3667 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3668 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3669 else return visitor.visitChildren(this); 3670 } 3671 } 3672 3673 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3674 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3675 enterRule(_localctx, 32, RULE_tdTagClose); 3676 int _la; 3677 try { 3678 enterOuterAlt(_localctx, 1); 3679 { 3680 setState(526); 3681 match(OPEN); 3682 setState(527); 3683 match(SLASH); 3684 setState(528); 3685 match(TD_HTML_TAG_NAME); 3686 setState(532); 3687 _errHandler.sync(this); 3688 _la = _input.LA(1); 3689 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3690 { 3691 { 3692 setState(529); 3693 _la = _input.LA(1); 3694 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3695 _errHandler.recoverInline(this); 3696 } 3697 else { 3698 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3699 _errHandler.reportMatch(this); 3700 consume(); 3701 } 3702 } 3703 } 3704 setState(534); 3705 _errHandler.sync(this); 3706 _la = _input.LA(1); 3707 } 3708 setState(535); 3709 match(CLOSE); 3710 } 3711 } 3712 catch (RecognitionException re) { 3713 _localctx.exception = re; 3714 _errHandler.reportError(this, re); 3715 _errHandler.recover(this, re); 3716 } 3717 finally { 3718 exitRule(); 3719 } 3720 return _localctx; 3721 } 3722 3723 public static class TdContext extends ParserRuleContext { 3724 public List<TdTagOpenContext> tdTagOpen() { 3725 return getRuleContexts(TdTagOpenContext.class); 3726 } 3727 public TdTagOpenContext tdTagOpen(int i) { 3728 return getRuleContext(TdTagOpenContext.class,i); 3729 } 3730 public TdTagCloseContext tdTagClose() { 3731 return getRuleContext(TdTagCloseContext.class,0); 3732 } 3733 public List<HtmlTagContext> htmlTag() { 3734 return getRuleContexts(HtmlTagContext.class); 3735 } 3736 public HtmlTagContext htmlTag(int i) { 3737 return getRuleContext(HtmlTagContext.class,i); 3738 } 3739 public List<SingletonTagContext> singletonTag() { 3740 return getRuleContexts(SingletonTagContext.class); 3741 } 3742 public SingletonTagContext singletonTag(int i) { 3743 return getRuleContext(SingletonTagContext.class,i); 3744 } 3745 public List<ParagraphContext> paragraph() { 3746 return getRuleContexts(ParagraphContext.class); 3747 } 3748 public ParagraphContext paragraph(int i) { 3749 return getRuleContext(ParagraphContext.class,i); 3750 } 3751 public List<LiContext> li() { 3752 return getRuleContexts(LiContext.class); 3753 } 3754 public LiContext li(int i) { 3755 return getRuleContext(LiContext.class,i); 3756 } 3757 public List<TrContext> tr() { 3758 return getRuleContexts(TrContext.class); 3759 } 3760 public TrContext tr(int i) { 3761 return getRuleContext(TrContext.class,i); 3762 } 3763 public List<ThContext> th() { 3764 return getRuleContexts(ThContext.class); 3765 } 3766 public ThContext th(int i) { 3767 return getRuleContext(ThContext.class,i); 3768 } 3769 public List<BodyContext> body() { 3770 return getRuleContexts(BodyContext.class); 3771 } 3772 public BodyContext body(int i) { 3773 return getRuleContext(BodyContext.class,i); 3774 } 3775 public List<ColgroupContext> colgroup() { 3776 return getRuleContexts(ColgroupContext.class); 3777 } 3778 public ColgroupContext colgroup(int i) { 3779 return getRuleContext(ColgroupContext.class,i); 3780 } 3781 public List<DdContext> dd() { 3782 return getRuleContexts(DdContext.class); 3783 } 3784 public DdContext dd(int i) { 3785 return getRuleContext(DdContext.class,i); 3786 } 3787 public List<DtContext> dt() { 3788 return getRuleContexts(DtContext.class); 3789 } 3790 public DtContext dt(int i) { 3791 return getRuleContext(DtContext.class,i); 3792 } 3793 public List<HeadContext> head() { 3794 return getRuleContexts(HeadContext.class); 3795 } 3796 public HeadContext head(int i) { 3797 return getRuleContext(HeadContext.class,i); 3798 } 3799 public List<HtmlContext> html() { 3800 return getRuleContexts(HtmlContext.class); 3801 } 3802 public HtmlContext html(int i) { 3803 return getRuleContext(HtmlContext.class,i); 3804 } 3805 public List<OptionContext> option() { 3806 return getRuleContexts(OptionContext.class); 3807 } 3808 public OptionContext option(int i) { 3809 return getRuleContext(OptionContext.class,i); 3810 } 3811 public List<TbodyContext> tbody() { 3812 return getRuleContexts(TbodyContext.class); 3813 } 3814 public TbodyContext tbody(int i) { 3815 return getRuleContext(TbodyContext.class,i); 3816 } 3817 public List<TheadContext> thead() { 3818 return getRuleContexts(TheadContext.class); 3819 } 3820 public TheadContext thead(int i) { 3821 return getRuleContext(TheadContext.class,i); 3822 } 3823 public List<TfootContext> tfoot() { 3824 return getRuleContexts(TfootContext.class); 3825 } 3826 public TfootContext tfoot(int i) { 3827 return getRuleContext(TfootContext.class,i); 3828 } 3829 public List<PTagOpenContext> pTagOpen() { 3830 return getRuleContexts(PTagOpenContext.class); 3831 } 3832 public PTagOpenContext pTagOpen(int i) { 3833 return getRuleContext(PTagOpenContext.class,i); 3834 } 3835 public List<LiTagOpenContext> liTagOpen() { 3836 return getRuleContexts(LiTagOpenContext.class); 3837 } 3838 public LiTagOpenContext liTagOpen(int i) { 3839 return getRuleContext(LiTagOpenContext.class,i); 3840 } 3841 public List<ThTagOpenContext> thTagOpen() { 3842 return getRuleContexts(ThTagOpenContext.class); 3843 } 3844 public ThTagOpenContext thTagOpen(int i) { 3845 return getRuleContext(ThTagOpenContext.class,i); 3846 } 3847 public List<BodyTagOpenContext> bodyTagOpen() { 3848 return getRuleContexts(BodyTagOpenContext.class); 3849 } 3850 public BodyTagOpenContext bodyTagOpen(int i) { 3851 return getRuleContext(BodyTagOpenContext.class,i); 3852 } 3853 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3854 return getRuleContexts(ColgroupTagOpenContext.class); 3855 } 3856 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3857 return getRuleContext(ColgroupTagOpenContext.class,i); 3858 } 3859 public List<DdTagOpenContext> ddTagOpen() { 3860 return getRuleContexts(DdTagOpenContext.class); 3861 } 3862 public DdTagOpenContext ddTagOpen(int i) { 3863 return getRuleContext(DdTagOpenContext.class,i); 3864 } 3865 public List<DtTagOpenContext> dtTagOpen() { 3866 return getRuleContexts(DtTagOpenContext.class); 3867 } 3868 public DtTagOpenContext dtTagOpen(int i) { 3869 return getRuleContext(DtTagOpenContext.class,i); 3870 } 3871 public List<HeadTagOpenContext> headTagOpen() { 3872 return getRuleContexts(HeadTagOpenContext.class); 3873 } 3874 public HeadTagOpenContext headTagOpen(int i) { 3875 return getRuleContext(HeadTagOpenContext.class,i); 3876 } 3877 public List<HtmlTagOpenContext> htmlTagOpen() { 3878 return getRuleContexts(HtmlTagOpenContext.class); 3879 } 3880 public HtmlTagOpenContext htmlTagOpen(int i) { 3881 return getRuleContext(HtmlTagOpenContext.class,i); 3882 } 3883 public List<OptionTagOpenContext> optionTagOpen() { 3884 return getRuleContexts(OptionTagOpenContext.class); 3885 } 3886 public OptionTagOpenContext optionTagOpen(int i) { 3887 return getRuleContext(OptionTagOpenContext.class,i); 3888 } 3889 public List<TbodyTagOpenContext> tbodyTagOpen() { 3890 return getRuleContexts(TbodyTagOpenContext.class); 3891 } 3892 public TbodyTagOpenContext tbodyTagOpen(int i) { 3893 return getRuleContext(TbodyTagOpenContext.class,i); 3894 } 3895 public List<TheadTagOpenContext> theadTagOpen() { 3896 return getRuleContexts(TheadTagOpenContext.class); 3897 } 3898 public TheadTagOpenContext theadTagOpen(int i) { 3899 return getRuleContext(TheadTagOpenContext.class,i); 3900 } 3901 public List<TfootTagOpenContext> tfootTagOpen() { 3902 return getRuleContexts(TfootTagOpenContext.class); 3903 } 3904 public TfootTagOpenContext tfootTagOpen(int i) { 3905 return getRuleContext(TfootTagOpenContext.class,i); 3906 } 3907 public List<HtmlCommentContext> htmlComment() { 3908 return getRuleContexts(HtmlCommentContext.class); 3909 } 3910 public HtmlCommentContext htmlComment(int i) { 3911 return getRuleContext(HtmlCommentContext.class,i); 3912 } 3913 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3914 public TerminalNode CDATA(int i) { 3915 return getToken(JavadocParser.CDATA, i); 3916 } 3917 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3918 public TerminalNode NEWLINE(int i) { 3919 return getToken(JavadocParser.NEWLINE, i); 3920 } 3921 public List<TextContext> text() { 3922 return getRuleContexts(TextContext.class); 3923 } 3924 public TextContext text(int i) { 3925 return getRuleContext(TextContext.class,i); 3926 } 3927 public List<JavadocInlineTagContext> javadocInlineTag() { 3928 return getRuleContexts(JavadocInlineTagContext.class); 3929 } 3930 public JavadocInlineTagContext javadocInlineTag(int i) { 3931 return getRuleContext(JavadocInlineTagContext.class,i); 3932 } 3933 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3934 public TerminalNode LEADING_ASTERISK(int i) { 3935 return getToken(JavadocParser.LEADING_ASTERISK, i); 3936 } 3937 public TdContext(ParserRuleContext parent, int invokingState) { 3938 super(parent, invokingState); 3939 } 3940 @Override public int getRuleIndex() { return RULE_td; } 3941 @Override 3942 public void enterRule(ParseTreeListener listener) { 3943 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3944 } 3945 @Override 3946 public void exitRule(ParseTreeListener listener) { 3947 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3948 } 3949 @Override 3950 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3951 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3952 else return visitor.visitChildren(this); 3953 } 3954 } 3955 3956 public final TdContext td() throws RecognitionException { 3957 TdContext _localctx = new TdContext(_ctx, getState()); 3958 enterRule(_localctx, 34, RULE_td); 3959 try { 3960 int _alt; 3961 enterOuterAlt(_localctx, 1); 3962 { 3963 setState(537); 3964 tdTagOpen(); 3965 setState(577); 3966 _errHandler.sync(this); 3967 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3968 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3969 if ( _alt==1 ) { 3970 { 3971 setState(575); 3972 _errHandler.sync(this); 3973 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3974 case 1: 3975 { 3976 setState(538); 3977 htmlTag(); 3978 } 3979 break; 3980 case 2: 3981 { 3982 setState(539); 3983 singletonTag(); 3984 } 3985 break; 3986 case 3: 3987 { 3988 setState(540); 3989 paragraph(); 3990 } 3991 break; 3992 case 4: 3993 { 3994 setState(541); 3995 li(); 3996 } 3997 break; 3998 case 5: 3999 { 4000 setState(542); 4001 tr(); 4002 } 4003 break; 4004 case 6: 4005 { 4006 setState(543); 4007 th(); 4008 } 4009 break; 4010 case 7: 4011 { 4012 setState(544); 4013 body(); 4014 } 4015 break; 4016 case 8: 4017 { 4018 setState(545); 4019 colgroup(); 4020 } 4021 break; 4022 case 9: 4023 { 4024 setState(546); 4025 dd(); 4026 } 4027 break; 4028 case 10: 4029 { 4030 setState(547); 4031 dt(); 4032 } 4033 break; 4034 case 11: 4035 { 4036 setState(548); 4037 head(); 4038 } 4039 break; 4040 case 12: 4041 { 4042 setState(549); 4043 html(); 4044 } 4045 break; 4046 case 13: 4047 { 4048 setState(550); 4049 option(); 4050 } 4051 break; 4052 case 14: 4053 { 4054 setState(551); 4055 tbody(); 4056 } 4057 break; 4058 case 15: 4059 { 4060 setState(552); 4061 thead(); 4062 } 4063 break; 4064 case 16: 4065 { 4066 setState(553); 4067 tfoot(); 4068 } 4069 break; 4070 case 17: 4071 { 4072 setState(554); 4073 pTagOpen(); 4074 } 4075 break; 4076 case 18: 4077 { 4078 setState(555); 4079 liTagOpen(); 4080 } 4081 break; 4082 case 19: 4083 { 4084 setState(556); 4085 tdTagOpen(); 4086 } 4087 break; 4088 case 20: 4089 { 4090 setState(557); 4091 thTagOpen(); 4092 } 4093 break; 4094 case 21: 4095 { 4096 setState(558); 4097 bodyTagOpen(); 4098 } 4099 break; 4100 case 22: 4101 { 4102 setState(559); 4103 colgroupTagOpen(); 4104 } 4105 break; 4106 case 23: 4107 { 4108 setState(560); 4109 ddTagOpen(); 4110 } 4111 break; 4112 case 24: 4113 { 4114 setState(561); 4115 dtTagOpen(); 4116 } 4117 break; 4118 case 25: 4119 { 4120 setState(562); 4121 headTagOpen(); 4122 } 4123 break; 4124 case 26: 4125 { 4126 setState(563); 4127 htmlTagOpen(); 4128 } 4129 break; 4130 case 27: 4131 { 4132 setState(564); 4133 optionTagOpen(); 4134 } 4135 break; 4136 case 28: 4137 { 4138 setState(565); 4139 tbodyTagOpen(); 4140 } 4141 break; 4142 case 29: 4143 { 4144 setState(566); 4145 theadTagOpen(); 4146 } 4147 break; 4148 case 30: 4149 { 4150 setState(567); 4151 tfootTagOpen(); 4152 } 4153 break; 4154 case 31: 4155 { 4156 { 4157 setState(568); 4158 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4159 setState(569); 4160 match(LEADING_ASTERISK); 4161 } 4162 } 4163 break; 4164 case 32: 4165 { 4166 setState(570); 4167 htmlComment(); 4168 } 4169 break; 4170 case 33: 4171 { 4172 setState(571); 4173 match(CDATA); 4174 } 4175 break; 4176 case 34: 4177 { 4178 setState(572); 4179 match(NEWLINE); 4180 } 4181 break; 4182 case 35: 4183 { 4184 setState(573); 4185 text(); 4186 } 4187 break; 4188 case 36: 4189 { 4190 setState(574); 4191 javadocInlineTag(); 4192 } 4193 break; 4194 } 4195 } 4196 } 4197 setState(579); 4198 _errHandler.sync(this); 4199 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4200 } 4201 setState(580); 4202 tdTagClose(); 4203 } 4204 } 4205 catch (RecognitionException re) { 4206 _localctx.exception = re; 4207 _errHandler.reportError(this, re); 4208 _errHandler.recover(this, re); 4209 } 4210 finally { 4211 exitRule(); 4212 } 4213 return _localctx; 4214 } 4215 4216 public static class ThTagOpenContext extends ParserRuleContext { 4217 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4218 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4219 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4220 public List<AttributeContext> attribute() { 4221 return getRuleContexts(AttributeContext.class); 4222 } 4223 public AttributeContext attribute(int i) { 4224 return getRuleContext(AttributeContext.class,i); 4225 } 4226 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4227 public TerminalNode NEWLINE(int i) { 4228 return getToken(JavadocParser.NEWLINE, i); 4229 } 4230 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4231 public TerminalNode LEADING_ASTERISK(int i) { 4232 return getToken(JavadocParser.LEADING_ASTERISK, i); 4233 } 4234 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4235 public TerminalNode WS(int i) { 4236 return getToken(JavadocParser.WS, i); 4237 } 4238 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4239 super(parent, invokingState); 4240 } 4241 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4242 @Override 4243 public void enterRule(ParseTreeListener listener) { 4244 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4245 } 4246 @Override 4247 public void exitRule(ParseTreeListener listener) { 4248 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4249 } 4250 @Override 4251 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4252 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4253 else return visitor.visitChildren(this); 4254 } 4255 } 4256 4257 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4258 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4259 enterRule(_localctx, 36, RULE_thTagOpen); 4260 int _la; 4261 try { 4262 enterOuterAlt(_localctx, 1); 4263 { 4264 setState(582); 4265 match(OPEN); 4266 setState(583); 4267 match(TH_HTML_TAG_NAME); 4268 setState(590); 4269 _errHandler.sync(this); 4270 _la = _input.LA(1); 4271 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4272 { 4273 setState(588); 4274 _errHandler.sync(this); 4275 switch (_input.LA(1)) { 4276 case HTML_TAG_NAME: 4277 { 4278 setState(584); 4279 attribute(); 4280 } 4281 break; 4282 case NEWLINE: 4283 { 4284 setState(585); 4285 match(NEWLINE); 4286 } 4287 break; 4288 case LEADING_ASTERISK: 4289 { 4290 setState(586); 4291 match(LEADING_ASTERISK); 4292 } 4293 break; 4294 case WS: 4295 { 4296 setState(587); 4297 match(WS); 4298 } 4299 break; 4300 default: 4301 throw new NoViableAltException(this); 4302 } 4303 } 4304 setState(592); 4305 _errHandler.sync(this); 4306 _la = _input.LA(1); 4307 } 4308 setState(593); 4309 match(CLOSE); 4310 } 4311 } 4312 catch (RecognitionException re) { 4313 _localctx.exception = re; 4314 _errHandler.reportError(this, re); 4315 _errHandler.recover(this, re); 4316 } 4317 finally { 4318 exitRule(); 4319 } 4320 return _localctx; 4321 } 4322 4323 public static class ThTagCloseContext extends ParserRuleContext { 4324 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4325 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4326 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4327 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4328 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4329 public TerminalNode NEWLINE(int i) { 4330 return getToken(JavadocParser.NEWLINE, i); 4331 } 4332 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4333 public TerminalNode LEADING_ASTERISK(int i) { 4334 return getToken(JavadocParser.LEADING_ASTERISK, i); 4335 } 4336 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4337 public TerminalNode WS(int i) { 4338 return getToken(JavadocParser.WS, i); 4339 } 4340 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4341 super(parent, invokingState); 4342 } 4343 @Override public int getRuleIndex() { return RULE_thTagClose; } 4344 @Override 4345 public void enterRule(ParseTreeListener listener) { 4346 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4347 } 4348 @Override 4349 public void exitRule(ParseTreeListener listener) { 4350 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4351 } 4352 @Override 4353 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4354 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4355 else return visitor.visitChildren(this); 4356 } 4357 } 4358 4359 public final ThTagCloseContext thTagClose() throws RecognitionException { 4360 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4361 enterRule(_localctx, 38, RULE_thTagClose); 4362 int _la; 4363 try { 4364 enterOuterAlt(_localctx, 1); 4365 { 4366 setState(595); 4367 match(OPEN); 4368 setState(596); 4369 match(SLASH); 4370 setState(597); 4371 match(TH_HTML_TAG_NAME); 4372 setState(601); 4373 _errHandler.sync(this); 4374 _la = _input.LA(1); 4375 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4376 { 4377 { 4378 setState(598); 4379 _la = _input.LA(1); 4380 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4381 _errHandler.recoverInline(this); 4382 } 4383 else { 4384 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4385 _errHandler.reportMatch(this); 4386 consume(); 4387 } 4388 } 4389 } 4390 setState(603); 4391 _errHandler.sync(this); 4392 _la = _input.LA(1); 4393 } 4394 setState(604); 4395 match(CLOSE); 4396 } 4397 } 4398 catch (RecognitionException re) { 4399 _localctx.exception = re; 4400 _errHandler.reportError(this, re); 4401 _errHandler.recover(this, re); 4402 } 4403 finally { 4404 exitRule(); 4405 } 4406 return _localctx; 4407 } 4408 4409 public static class ThContext extends ParserRuleContext { 4410 public ThTagOpenContext thTagOpen() { 4411 return getRuleContext(ThTagOpenContext.class,0); 4412 } 4413 public ThTagCloseContext thTagClose() { 4414 return getRuleContext(ThTagCloseContext.class,0); 4415 } 4416 public List<HtmlTagContext> htmlTag() { 4417 return getRuleContexts(HtmlTagContext.class); 4418 } 4419 public HtmlTagContext htmlTag(int i) { 4420 return getRuleContext(HtmlTagContext.class,i); 4421 } 4422 public List<SingletonTagContext> singletonTag() { 4423 return getRuleContexts(SingletonTagContext.class); 4424 } 4425 public SingletonTagContext singletonTag(int i) { 4426 return getRuleContext(SingletonTagContext.class,i); 4427 } 4428 public List<ParagraphContext> paragraph() { 4429 return getRuleContexts(ParagraphContext.class); 4430 } 4431 public ParagraphContext paragraph(int i) { 4432 return getRuleContext(ParagraphContext.class,i); 4433 } 4434 public List<LiContext> li() { 4435 return getRuleContexts(LiContext.class); 4436 } 4437 public LiContext li(int i) { 4438 return getRuleContext(LiContext.class,i); 4439 } 4440 public List<TrContext> tr() { 4441 return getRuleContexts(TrContext.class); 4442 } 4443 public TrContext tr(int i) { 4444 return getRuleContext(TrContext.class,i); 4445 } 4446 public List<TdContext> td() { 4447 return getRuleContexts(TdContext.class); 4448 } 4449 public TdContext td(int i) { 4450 return getRuleContext(TdContext.class,i); 4451 } 4452 public List<BodyContext> body() { 4453 return getRuleContexts(BodyContext.class); 4454 } 4455 public BodyContext body(int i) { 4456 return getRuleContext(BodyContext.class,i); 4457 } 4458 public List<ColgroupContext> colgroup() { 4459 return getRuleContexts(ColgroupContext.class); 4460 } 4461 public ColgroupContext colgroup(int i) { 4462 return getRuleContext(ColgroupContext.class,i); 4463 } 4464 public List<DdContext> dd() { 4465 return getRuleContexts(DdContext.class); 4466 } 4467 public DdContext dd(int i) { 4468 return getRuleContext(DdContext.class,i); 4469 } 4470 public List<DtContext> dt() { 4471 return getRuleContexts(DtContext.class); 4472 } 4473 public DtContext dt(int i) { 4474 return getRuleContext(DtContext.class,i); 4475 } 4476 public List<HeadContext> head() { 4477 return getRuleContexts(HeadContext.class); 4478 } 4479 public HeadContext head(int i) { 4480 return getRuleContext(HeadContext.class,i); 4481 } 4482 public List<HtmlContext> html() { 4483 return getRuleContexts(HtmlContext.class); 4484 } 4485 public HtmlContext html(int i) { 4486 return getRuleContext(HtmlContext.class,i); 4487 } 4488 public List<OptionContext> option() { 4489 return getRuleContexts(OptionContext.class); 4490 } 4491 public OptionContext option(int i) { 4492 return getRuleContext(OptionContext.class,i); 4493 } 4494 public List<TbodyContext> tbody() { 4495 return getRuleContexts(TbodyContext.class); 4496 } 4497 public TbodyContext tbody(int i) { 4498 return getRuleContext(TbodyContext.class,i); 4499 } 4500 public List<TheadContext> thead() { 4501 return getRuleContexts(TheadContext.class); 4502 } 4503 public TheadContext thead(int i) { 4504 return getRuleContext(TheadContext.class,i); 4505 } 4506 public List<TfootContext> tfoot() { 4507 return getRuleContexts(TfootContext.class); 4508 } 4509 public TfootContext tfoot(int i) { 4510 return getRuleContext(TfootContext.class,i); 4511 } 4512 public List<PTagOpenContext> pTagOpen() { 4513 return getRuleContexts(PTagOpenContext.class); 4514 } 4515 public PTagOpenContext pTagOpen(int i) { 4516 return getRuleContext(PTagOpenContext.class,i); 4517 } 4518 public List<LiTagOpenContext> liTagOpen() { 4519 return getRuleContexts(LiTagOpenContext.class); 4520 } 4521 public LiTagOpenContext liTagOpen(int i) { 4522 return getRuleContext(LiTagOpenContext.class,i); 4523 } 4524 public List<TrTagOpenContext> trTagOpen() { 4525 return getRuleContexts(TrTagOpenContext.class); 4526 } 4527 public TrTagOpenContext trTagOpen(int i) { 4528 return getRuleContext(TrTagOpenContext.class,i); 4529 } 4530 public List<TdTagOpenContext> tdTagOpen() { 4531 return getRuleContexts(TdTagOpenContext.class); 4532 } 4533 public TdTagOpenContext tdTagOpen(int i) { 4534 return getRuleContext(TdTagOpenContext.class,i); 4535 } 4536 public List<BodyTagOpenContext> bodyTagOpen() { 4537 return getRuleContexts(BodyTagOpenContext.class); 4538 } 4539 public BodyTagOpenContext bodyTagOpen(int i) { 4540 return getRuleContext(BodyTagOpenContext.class,i); 4541 } 4542 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4543 return getRuleContexts(ColgroupTagOpenContext.class); 4544 } 4545 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4546 return getRuleContext(ColgroupTagOpenContext.class,i); 4547 } 4548 public List<DdTagOpenContext> ddTagOpen() { 4549 return getRuleContexts(DdTagOpenContext.class); 4550 } 4551 public DdTagOpenContext ddTagOpen(int i) { 4552 return getRuleContext(DdTagOpenContext.class,i); 4553 } 4554 public List<DtTagOpenContext> dtTagOpen() { 4555 return getRuleContexts(DtTagOpenContext.class); 4556 } 4557 public DtTagOpenContext dtTagOpen(int i) { 4558 return getRuleContext(DtTagOpenContext.class,i); 4559 } 4560 public List<HeadTagOpenContext> headTagOpen() { 4561 return getRuleContexts(HeadTagOpenContext.class); 4562 } 4563 public HeadTagOpenContext headTagOpen(int i) { 4564 return getRuleContext(HeadTagOpenContext.class,i); 4565 } 4566 public List<HtmlTagOpenContext> htmlTagOpen() { 4567 return getRuleContexts(HtmlTagOpenContext.class); 4568 } 4569 public HtmlTagOpenContext htmlTagOpen(int i) { 4570 return getRuleContext(HtmlTagOpenContext.class,i); 4571 } 4572 public List<OptionTagOpenContext> optionTagOpen() { 4573 return getRuleContexts(OptionTagOpenContext.class); 4574 } 4575 public OptionTagOpenContext optionTagOpen(int i) { 4576 return getRuleContext(OptionTagOpenContext.class,i); 4577 } 4578 public List<TbodyTagOpenContext> tbodyTagOpen() { 4579 return getRuleContexts(TbodyTagOpenContext.class); 4580 } 4581 public TbodyTagOpenContext tbodyTagOpen(int i) { 4582 return getRuleContext(TbodyTagOpenContext.class,i); 4583 } 4584 public List<TheadTagOpenContext> theadTagOpen() { 4585 return getRuleContexts(TheadTagOpenContext.class); 4586 } 4587 public TheadTagOpenContext theadTagOpen(int i) { 4588 return getRuleContext(TheadTagOpenContext.class,i); 4589 } 4590 public List<TfootTagOpenContext> tfootTagOpen() { 4591 return getRuleContexts(TfootTagOpenContext.class); 4592 } 4593 public TfootTagOpenContext tfootTagOpen(int i) { 4594 return getRuleContext(TfootTagOpenContext.class,i); 4595 } 4596 public List<HtmlCommentContext> htmlComment() { 4597 return getRuleContexts(HtmlCommentContext.class); 4598 } 4599 public HtmlCommentContext htmlComment(int i) { 4600 return getRuleContext(HtmlCommentContext.class,i); 4601 } 4602 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4603 public TerminalNode CDATA(int i) { 4604 return getToken(JavadocParser.CDATA, i); 4605 } 4606 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4607 public TerminalNode NEWLINE(int i) { 4608 return getToken(JavadocParser.NEWLINE, i); 4609 } 4610 public List<TextContext> text() { 4611 return getRuleContexts(TextContext.class); 4612 } 4613 public TextContext text(int i) { 4614 return getRuleContext(TextContext.class,i); 4615 } 4616 public List<JavadocInlineTagContext> javadocInlineTag() { 4617 return getRuleContexts(JavadocInlineTagContext.class); 4618 } 4619 public JavadocInlineTagContext javadocInlineTag(int i) { 4620 return getRuleContext(JavadocInlineTagContext.class,i); 4621 } 4622 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4623 public TerminalNode LEADING_ASTERISK(int i) { 4624 return getToken(JavadocParser.LEADING_ASTERISK, i); 4625 } 4626 public ThContext(ParserRuleContext parent, int invokingState) { 4627 super(parent, invokingState); 4628 } 4629 @Override public int getRuleIndex() { return RULE_th; } 4630 @Override 4631 public void enterRule(ParseTreeListener listener) { 4632 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4633 } 4634 @Override 4635 public void exitRule(ParseTreeListener listener) { 4636 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4637 } 4638 @Override 4639 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4640 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4641 else return visitor.visitChildren(this); 4642 } 4643 } 4644 4645 public final ThContext th() throws RecognitionException { 4646 ThContext _localctx = new ThContext(_ctx, getState()); 4647 enterRule(_localctx, 40, RULE_th); 4648 try { 4649 int _alt; 4650 enterOuterAlt(_localctx, 1); 4651 { 4652 setState(606); 4653 thTagOpen(); 4654 setState(646); 4655 _errHandler.sync(this); 4656 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4657 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4658 if ( _alt==1 ) { 4659 { 4660 setState(644); 4661 _errHandler.sync(this); 4662 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4663 case 1: 4664 { 4665 setState(607); 4666 htmlTag(); 4667 } 4668 break; 4669 case 2: 4670 { 4671 setState(608); 4672 singletonTag(); 4673 } 4674 break; 4675 case 3: 4676 { 4677 setState(609); 4678 paragraph(); 4679 } 4680 break; 4681 case 4: 4682 { 4683 setState(610); 4684 li(); 4685 } 4686 break; 4687 case 5: 4688 { 4689 setState(611); 4690 tr(); 4691 } 4692 break; 4693 case 6: 4694 { 4695 setState(612); 4696 td(); 4697 } 4698 break; 4699 case 7: 4700 { 4701 setState(613); 4702 body(); 4703 } 4704 break; 4705 case 8: 4706 { 4707 setState(614); 4708 colgroup(); 4709 } 4710 break; 4711 case 9: 4712 { 4713 setState(615); 4714 dd(); 4715 } 4716 break; 4717 case 10: 4718 { 4719 setState(616); 4720 dt(); 4721 } 4722 break; 4723 case 11: 4724 { 4725 setState(617); 4726 head(); 4727 } 4728 break; 4729 case 12: 4730 { 4731 setState(618); 4732 html(); 4733 } 4734 break; 4735 case 13: 4736 { 4737 setState(619); 4738 option(); 4739 } 4740 break; 4741 case 14: 4742 { 4743 setState(620); 4744 tbody(); 4745 } 4746 break; 4747 case 15: 4748 { 4749 setState(621); 4750 thead(); 4751 } 4752 break; 4753 case 16: 4754 { 4755 setState(622); 4756 tfoot(); 4757 } 4758 break; 4759 case 17: 4760 { 4761 setState(623); 4762 pTagOpen(); 4763 } 4764 break; 4765 case 18: 4766 { 4767 setState(624); 4768 liTagOpen(); 4769 } 4770 break; 4771 case 19: 4772 { 4773 setState(625); 4774 trTagOpen(); 4775 } 4776 break; 4777 case 20: 4778 { 4779 setState(626); 4780 tdTagOpen(); 4781 } 4782 break; 4783 case 21: 4784 { 4785 setState(627); 4786 bodyTagOpen(); 4787 } 4788 break; 4789 case 22: 4790 { 4791 setState(628); 4792 colgroupTagOpen(); 4793 } 4794 break; 4795 case 23: 4796 { 4797 setState(629); 4798 ddTagOpen(); 4799 } 4800 break; 4801 case 24: 4802 { 4803 setState(630); 4804 dtTagOpen(); 4805 } 4806 break; 4807 case 25: 4808 { 4809 setState(631); 4810 headTagOpen(); 4811 } 4812 break; 4813 case 26: 4814 { 4815 setState(632); 4816 htmlTagOpen(); 4817 } 4818 break; 4819 case 27: 4820 { 4821 setState(633); 4822 optionTagOpen(); 4823 } 4824 break; 4825 case 28: 4826 { 4827 setState(634); 4828 tbodyTagOpen(); 4829 } 4830 break; 4831 case 29: 4832 { 4833 setState(635); 4834 theadTagOpen(); 4835 } 4836 break; 4837 case 30: 4838 { 4839 setState(636); 4840 tfootTagOpen(); 4841 } 4842 break; 4843 case 31: 4844 { 4845 { 4846 setState(637); 4847 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4848 setState(638); 4849 match(LEADING_ASTERISK); 4850 } 4851 } 4852 break; 4853 case 32: 4854 { 4855 setState(639); 4856 htmlComment(); 4857 } 4858 break; 4859 case 33: 4860 { 4861 setState(640); 4862 match(CDATA); 4863 } 4864 break; 4865 case 34: 4866 { 4867 setState(641); 4868 match(NEWLINE); 4869 } 4870 break; 4871 case 35: 4872 { 4873 setState(642); 4874 text(); 4875 } 4876 break; 4877 case 36: 4878 { 4879 setState(643); 4880 javadocInlineTag(); 4881 } 4882 break; 4883 } 4884 } 4885 } 4886 setState(648); 4887 _errHandler.sync(this); 4888 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4889 } 4890 setState(649); 4891 thTagClose(); 4892 } 4893 } 4894 catch (RecognitionException re) { 4895 _localctx.exception = re; 4896 _errHandler.reportError(this, re); 4897 _errHandler.recover(this, re); 4898 } 4899 finally { 4900 exitRule(); 4901 } 4902 return _localctx; 4903 } 4904 4905 public static class BodyTagOpenContext extends ParserRuleContext { 4906 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4907 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4908 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4909 public List<AttributeContext> attribute() { 4910 return getRuleContexts(AttributeContext.class); 4911 } 4912 public AttributeContext attribute(int i) { 4913 return getRuleContext(AttributeContext.class,i); 4914 } 4915 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4916 public TerminalNode NEWLINE(int i) { 4917 return getToken(JavadocParser.NEWLINE, i); 4918 } 4919 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4920 public TerminalNode LEADING_ASTERISK(int i) { 4921 return getToken(JavadocParser.LEADING_ASTERISK, i); 4922 } 4923 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4924 public TerminalNode WS(int i) { 4925 return getToken(JavadocParser.WS, i); 4926 } 4927 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4928 super(parent, invokingState); 4929 } 4930 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4931 @Override 4932 public void enterRule(ParseTreeListener listener) { 4933 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4934 } 4935 @Override 4936 public void exitRule(ParseTreeListener listener) { 4937 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4938 } 4939 @Override 4940 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4941 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4942 else return visitor.visitChildren(this); 4943 } 4944 } 4945 4946 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4947 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4948 enterRule(_localctx, 42, RULE_bodyTagOpen); 4949 int _la; 4950 try { 4951 enterOuterAlt(_localctx, 1); 4952 { 4953 setState(651); 4954 match(OPEN); 4955 setState(652); 4956 match(BODY_HTML_TAG_NAME); 4957 setState(659); 4958 _errHandler.sync(this); 4959 _la = _input.LA(1); 4960 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4961 { 4962 setState(657); 4963 _errHandler.sync(this); 4964 switch (_input.LA(1)) { 4965 case HTML_TAG_NAME: 4966 { 4967 setState(653); 4968 attribute(); 4969 } 4970 break; 4971 case NEWLINE: 4972 { 4973 setState(654); 4974 match(NEWLINE); 4975 } 4976 break; 4977 case LEADING_ASTERISK: 4978 { 4979 setState(655); 4980 match(LEADING_ASTERISK); 4981 } 4982 break; 4983 case WS: 4984 { 4985 setState(656); 4986 match(WS); 4987 } 4988 break; 4989 default: 4990 throw new NoViableAltException(this); 4991 } 4992 } 4993 setState(661); 4994 _errHandler.sync(this); 4995 _la = _input.LA(1); 4996 } 4997 setState(662); 4998 match(CLOSE); 4999 } 5000 } 5001 catch (RecognitionException re) { 5002 _localctx.exception = re; 5003 _errHandler.reportError(this, re); 5004 _errHandler.recover(this, re); 5005 } 5006 finally { 5007 exitRule(); 5008 } 5009 return _localctx; 5010 } 5011 5012 public static class BodyTagCloseContext extends ParserRuleContext { 5013 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5014 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5015 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5016 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5017 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5018 public TerminalNode NEWLINE(int i) { 5019 return getToken(JavadocParser.NEWLINE, i); 5020 } 5021 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5022 public TerminalNode LEADING_ASTERISK(int i) { 5023 return getToken(JavadocParser.LEADING_ASTERISK, i); 5024 } 5025 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5026 public TerminalNode WS(int i) { 5027 return getToken(JavadocParser.WS, i); 5028 } 5029 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 5030 super(parent, invokingState); 5031 } 5032 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 5033 @Override 5034 public void enterRule(ParseTreeListener listener) { 5035 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 5036 } 5037 @Override 5038 public void exitRule(ParseTreeListener listener) { 5039 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 5040 } 5041 @Override 5042 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5043 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 5044 else return visitor.visitChildren(this); 5045 } 5046 } 5047 5048 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 5049 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 5050 enterRule(_localctx, 44, RULE_bodyTagClose); 5051 int _la; 5052 try { 5053 enterOuterAlt(_localctx, 1); 5054 { 5055 setState(664); 5056 match(OPEN); 5057 setState(665); 5058 match(SLASH); 5059 setState(666); 5060 match(BODY_HTML_TAG_NAME); 5061 setState(670); 5062 _errHandler.sync(this); 5063 _la = _input.LA(1); 5064 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5065 { 5066 { 5067 setState(667); 5068 _la = _input.LA(1); 5069 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5070 _errHandler.recoverInline(this); 5071 } 5072 else { 5073 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5074 _errHandler.reportMatch(this); 5075 consume(); 5076 } 5077 } 5078 } 5079 setState(672); 5080 _errHandler.sync(this); 5081 _la = _input.LA(1); 5082 } 5083 setState(673); 5084 match(CLOSE); 5085 } 5086 } 5087 catch (RecognitionException re) { 5088 _localctx.exception = re; 5089 _errHandler.reportError(this, re); 5090 _errHandler.recover(this, re); 5091 } 5092 finally { 5093 exitRule(); 5094 } 5095 return _localctx; 5096 } 5097 5098 public static class BodyContext extends ParserRuleContext { 5099 public BodyTagOpenContext bodyTagOpen() { 5100 return getRuleContext(BodyTagOpenContext.class,0); 5101 } 5102 public BodyTagCloseContext bodyTagClose() { 5103 return getRuleContext(BodyTagCloseContext.class,0); 5104 } 5105 public List<HtmlTagContext> htmlTag() { 5106 return getRuleContexts(HtmlTagContext.class); 5107 } 5108 public HtmlTagContext htmlTag(int i) { 5109 return getRuleContext(HtmlTagContext.class,i); 5110 } 5111 public List<SingletonTagContext> singletonTag() { 5112 return getRuleContexts(SingletonTagContext.class); 5113 } 5114 public SingletonTagContext singletonTag(int i) { 5115 return getRuleContext(SingletonTagContext.class,i); 5116 } 5117 public List<ParagraphContext> paragraph() { 5118 return getRuleContexts(ParagraphContext.class); 5119 } 5120 public ParagraphContext paragraph(int i) { 5121 return getRuleContext(ParagraphContext.class,i); 5122 } 5123 public List<LiContext> li() { 5124 return getRuleContexts(LiContext.class); 5125 } 5126 public LiContext li(int i) { 5127 return getRuleContext(LiContext.class,i); 5128 } 5129 public List<TrContext> tr() { 5130 return getRuleContexts(TrContext.class); 5131 } 5132 public TrContext tr(int i) { 5133 return getRuleContext(TrContext.class,i); 5134 } 5135 public List<TdContext> td() { 5136 return getRuleContexts(TdContext.class); 5137 } 5138 public TdContext td(int i) { 5139 return getRuleContext(TdContext.class,i); 5140 } 5141 public List<ThContext> th() { 5142 return getRuleContexts(ThContext.class); 5143 } 5144 public ThContext th(int i) { 5145 return getRuleContext(ThContext.class,i); 5146 } 5147 public List<ColgroupContext> colgroup() { 5148 return getRuleContexts(ColgroupContext.class); 5149 } 5150 public ColgroupContext colgroup(int i) { 5151 return getRuleContext(ColgroupContext.class,i); 5152 } 5153 public List<DdContext> dd() { 5154 return getRuleContexts(DdContext.class); 5155 } 5156 public DdContext dd(int i) { 5157 return getRuleContext(DdContext.class,i); 5158 } 5159 public List<DtContext> dt() { 5160 return getRuleContexts(DtContext.class); 5161 } 5162 public DtContext dt(int i) { 5163 return getRuleContext(DtContext.class,i); 5164 } 5165 public List<HeadContext> head() { 5166 return getRuleContexts(HeadContext.class); 5167 } 5168 public HeadContext head(int i) { 5169 return getRuleContext(HeadContext.class,i); 5170 } 5171 public List<HtmlContext> html() { 5172 return getRuleContexts(HtmlContext.class); 5173 } 5174 public HtmlContext html(int i) { 5175 return getRuleContext(HtmlContext.class,i); 5176 } 5177 public List<OptionContext> option() { 5178 return getRuleContexts(OptionContext.class); 5179 } 5180 public OptionContext option(int i) { 5181 return getRuleContext(OptionContext.class,i); 5182 } 5183 public List<TbodyContext> tbody() { 5184 return getRuleContexts(TbodyContext.class); 5185 } 5186 public TbodyContext tbody(int i) { 5187 return getRuleContext(TbodyContext.class,i); 5188 } 5189 public List<TheadContext> thead() { 5190 return getRuleContexts(TheadContext.class); 5191 } 5192 public TheadContext thead(int i) { 5193 return getRuleContext(TheadContext.class,i); 5194 } 5195 public List<TfootContext> tfoot() { 5196 return getRuleContexts(TfootContext.class); 5197 } 5198 public TfootContext tfoot(int i) { 5199 return getRuleContext(TfootContext.class,i); 5200 } 5201 public List<PTagOpenContext> pTagOpen() { 5202 return getRuleContexts(PTagOpenContext.class); 5203 } 5204 public PTagOpenContext pTagOpen(int i) { 5205 return getRuleContext(PTagOpenContext.class,i); 5206 } 5207 public List<LiTagOpenContext> liTagOpen() { 5208 return getRuleContexts(LiTagOpenContext.class); 5209 } 5210 public LiTagOpenContext liTagOpen(int i) { 5211 return getRuleContext(LiTagOpenContext.class,i); 5212 } 5213 public List<TrTagOpenContext> trTagOpen() { 5214 return getRuleContexts(TrTagOpenContext.class); 5215 } 5216 public TrTagOpenContext trTagOpen(int i) { 5217 return getRuleContext(TrTagOpenContext.class,i); 5218 } 5219 public List<TdTagOpenContext> tdTagOpen() { 5220 return getRuleContexts(TdTagOpenContext.class); 5221 } 5222 public TdTagOpenContext tdTagOpen(int i) { 5223 return getRuleContext(TdTagOpenContext.class,i); 5224 } 5225 public List<ThTagOpenContext> thTagOpen() { 5226 return getRuleContexts(ThTagOpenContext.class); 5227 } 5228 public ThTagOpenContext thTagOpen(int i) { 5229 return getRuleContext(ThTagOpenContext.class,i); 5230 } 5231 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5232 return getRuleContexts(ColgroupTagOpenContext.class); 5233 } 5234 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5235 return getRuleContext(ColgroupTagOpenContext.class,i); 5236 } 5237 public List<DdTagOpenContext> ddTagOpen() { 5238 return getRuleContexts(DdTagOpenContext.class); 5239 } 5240 public DdTagOpenContext ddTagOpen(int i) { 5241 return getRuleContext(DdTagOpenContext.class,i); 5242 } 5243 public List<DtTagOpenContext> dtTagOpen() { 5244 return getRuleContexts(DtTagOpenContext.class); 5245 } 5246 public DtTagOpenContext dtTagOpen(int i) { 5247 return getRuleContext(DtTagOpenContext.class,i); 5248 } 5249 public List<HeadTagOpenContext> headTagOpen() { 5250 return getRuleContexts(HeadTagOpenContext.class); 5251 } 5252 public HeadTagOpenContext headTagOpen(int i) { 5253 return getRuleContext(HeadTagOpenContext.class,i); 5254 } 5255 public List<HtmlTagOpenContext> htmlTagOpen() { 5256 return getRuleContexts(HtmlTagOpenContext.class); 5257 } 5258 public HtmlTagOpenContext htmlTagOpen(int i) { 5259 return getRuleContext(HtmlTagOpenContext.class,i); 5260 } 5261 public List<OptionTagOpenContext> optionTagOpen() { 5262 return getRuleContexts(OptionTagOpenContext.class); 5263 } 5264 public OptionTagOpenContext optionTagOpen(int i) { 5265 return getRuleContext(OptionTagOpenContext.class,i); 5266 } 5267 public List<TbodyTagOpenContext> tbodyTagOpen() { 5268 return getRuleContexts(TbodyTagOpenContext.class); 5269 } 5270 public TbodyTagOpenContext tbodyTagOpen(int i) { 5271 return getRuleContext(TbodyTagOpenContext.class,i); 5272 } 5273 public List<TheadTagOpenContext> theadTagOpen() { 5274 return getRuleContexts(TheadTagOpenContext.class); 5275 } 5276 public TheadTagOpenContext theadTagOpen(int i) { 5277 return getRuleContext(TheadTagOpenContext.class,i); 5278 } 5279 public List<TfootTagOpenContext> tfootTagOpen() { 5280 return getRuleContexts(TfootTagOpenContext.class); 5281 } 5282 public TfootTagOpenContext tfootTagOpen(int i) { 5283 return getRuleContext(TfootTagOpenContext.class,i); 5284 } 5285 public List<HtmlCommentContext> htmlComment() { 5286 return getRuleContexts(HtmlCommentContext.class); 5287 } 5288 public HtmlCommentContext htmlComment(int i) { 5289 return getRuleContext(HtmlCommentContext.class,i); 5290 } 5291 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5292 public TerminalNode CDATA(int i) { 5293 return getToken(JavadocParser.CDATA, i); 5294 } 5295 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5296 public TerminalNode NEWLINE(int i) { 5297 return getToken(JavadocParser.NEWLINE, i); 5298 } 5299 public List<TextContext> text() { 5300 return getRuleContexts(TextContext.class); 5301 } 5302 public TextContext text(int i) { 5303 return getRuleContext(TextContext.class,i); 5304 } 5305 public List<JavadocInlineTagContext> javadocInlineTag() { 5306 return getRuleContexts(JavadocInlineTagContext.class); 5307 } 5308 public JavadocInlineTagContext javadocInlineTag(int i) { 5309 return getRuleContext(JavadocInlineTagContext.class,i); 5310 } 5311 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5312 public TerminalNode LEADING_ASTERISK(int i) { 5313 return getToken(JavadocParser.LEADING_ASTERISK, i); 5314 } 5315 public BodyContext(ParserRuleContext parent, int invokingState) { 5316 super(parent, invokingState); 5317 } 5318 @Override public int getRuleIndex() { return RULE_body; } 5319 @Override 5320 public void enterRule(ParseTreeListener listener) { 5321 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5322 } 5323 @Override 5324 public void exitRule(ParseTreeListener listener) { 5325 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5326 } 5327 @Override 5328 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5329 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5330 else return visitor.visitChildren(this); 5331 } 5332 } 5333 5334 public final BodyContext body() throws RecognitionException { 5335 BodyContext _localctx = new BodyContext(_ctx, getState()); 5336 enterRule(_localctx, 46, RULE_body); 5337 try { 5338 int _alt; 5339 enterOuterAlt(_localctx, 1); 5340 { 5341 setState(675); 5342 bodyTagOpen(); 5343 setState(715); 5344 _errHandler.sync(this); 5345 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5346 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5347 if ( _alt==1 ) { 5348 { 5349 setState(713); 5350 _errHandler.sync(this); 5351 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5352 case 1: 5353 { 5354 setState(676); 5355 htmlTag(); 5356 } 5357 break; 5358 case 2: 5359 { 5360 setState(677); 5361 singletonTag(); 5362 } 5363 break; 5364 case 3: 5365 { 5366 setState(678); 5367 paragraph(); 5368 } 5369 break; 5370 case 4: 5371 { 5372 setState(679); 5373 li(); 5374 } 5375 break; 5376 case 5: 5377 { 5378 setState(680); 5379 tr(); 5380 } 5381 break; 5382 case 6: 5383 { 5384 setState(681); 5385 td(); 5386 } 5387 break; 5388 case 7: 5389 { 5390 setState(682); 5391 th(); 5392 } 5393 break; 5394 case 8: 5395 { 5396 setState(683); 5397 colgroup(); 5398 } 5399 break; 5400 case 9: 5401 { 5402 setState(684); 5403 dd(); 5404 } 5405 break; 5406 case 10: 5407 { 5408 setState(685); 5409 dt(); 5410 } 5411 break; 5412 case 11: 5413 { 5414 setState(686); 5415 head(); 5416 } 5417 break; 5418 case 12: 5419 { 5420 setState(687); 5421 html(); 5422 } 5423 break; 5424 case 13: 5425 { 5426 setState(688); 5427 option(); 5428 } 5429 break; 5430 case 14: 5431 { 5432 setState(689); 5433 tbody(); 5434 } 5435 break; 5436 case 15: 5437 { 5438 setState(690); 5439 thead(); 5440 } 5441 break; 5442 case 16: 5443 { 5444 setState(691); 5445 tfoot(); 5446 } 5447 break; 5448 case 17: 5449 { 5450 setState(692); 5451 pTagOpen(); 5452 } 5453 break; 5454 case 18: 5455 { 5456 setState(693); 5457 liTagOpen(); 5458 } 5459 break; 5460 case 19: 5461 { 5462 setState(694); 5463 trTagOpen(); 5464 } 5465 break; 5466 case 20: 5467 { 5468 setState(695); 5469 tdTagOpen(); 5470 } 5471 break; 5472 case 21: 5473 { 5474 setState(696); 5475 thTagOpen(); 5476 } 5477 break; 5478 case 22: 5479 { 5480 setState(697); 5481 colgroupTagOpen(); 5482 } 5483 break; 5484 case 23: 5485 { 5486 setState(698); 5487 ddTagOpen(); 5488 } 5489 break; 5490 case 24: 5491 { 5492 setState(699); 5493 dtTagOpen(); 5494 } 5495 break; 5496 case 25: 5497 { 5498 setState(700); 5499 headTagOpen(); 5500 } 5501 break; 5502 case 26: 5503 { 5504 setState(701); 5505 htmlTagOpen(); 5506 } 5507 break; 5508 case 27: 5509 { 5510 setState(702); 5511 optionTagOpen(); 5512 } 5513 break; 5514 case 28: 5515 { 5516 setState(703); 5517 tbodyTagOpen(); 5518 } 5519 break; 5520 case 29: 5521 { 5522 setState(704); 5523 theadTagOpen(); 5524 } 5525 break; 5526 case 30: 5527 { 5528 setState(705); 5529 tfootTagOpen(); 5530 } 5531 break; 5532 case 31: 5533 { 5534 { 5535 setState(706); 5536 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5537 setState(707); 5538 match(LEADING_ASTERISK); 5539 } 5540 } 5541 break; 5542 case 32: 5543 { 5544 setState(708); 5545 htmlComment(); 5546 } 5547 break; 5548 case 33: 5549 { 5550 setState(709); 5551 match(CDATA); 5552 } 5553 break; 5554 case 34: 5555 { 5556 setState(710); 5557 match(NEWLINE); 5558 } 5559 break; 5560 case 35: 5561 { 5562 setState(711); 5563 text(); 5564 } 5565 break; 5566 case 36: 5567 { 5568 setState(712); 5569 javadocInlineTag(); 5570 } 5571 break; 5572 } 5573 } 5574 } 5575 setState(717); 5576 _errHandler.sync(this); 5577 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5578 } 5579 setState(718); 5580 bodyTagClose(); 5581 } 5582 } 5583 catch (RecognitionException re) { 5584 _localctx.exception = re; 5585 _errHandler.reportError(this, re); 5586 _errHandler.recover(this, re); 5587 } 5588 finally { 5589 exitRule(); 5590 } 5591 return _localctx; 5592 } 5593 5594 public static class ColgroupTagOpenContext extends ParserRuleContext { 5595 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5596 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5597 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5598 public List<AttributeContext> attribute() { 5599 return getRuleContexts(AttributeContext.class); 5600 } 5601 public AttributeContext attribute(int i) { 5602 return getRuleContext(AttributeContext.class,i); 5603 } 5604 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5605 public TerminalNode NEWLINE(int i) { 5606 return getToken(JavadocParser.NEWLINE, i); 5607 } 5608 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5609 public TerminalNode LEADING_ASTERISK(int i) { 5610 return getToken(JavadocParser.LEADING_ASTERISK, i); 5611 } 5612 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5613 public TerminalNode WS(int i) { 5614 return getToken(JavadocParser.WS, i); 5615 } 5616 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5617 super(parent, invokingState); 5618 } 5619 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5620 @Override 5621 public void enterRule(ParseTreeListener listener) { 5622 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5623 } 5624 @Override 5625 public void exitRule(ParseTreeListener listener) { 5626 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5627 } 5628 @Override 5629 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5630 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5631 else return visitor.visitChildren(this); 5632 } 5633 } 5634 5635 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5636 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5637 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5638 int _la; 5639 try { 5640 enterOuterAlt(_localctx, 1); 5641 { 5642 setState(720); 5643 match(OPEN); 5644 setState(721); 5645 match(COLGROUP_HTML_TAG_NAME); 5646 setState(728); 5647 _errHandler.sync(this); 5648 _la = _input.LA(1); 5649 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5650 { 5651 setState(726); 5652 _errHandler.sync(this); 5653 switch (_input.LA(1)) { 5654 case HTML_TAG_NAME: 5655 { 5656 setState(722); 5657 attribute(); 5658 } 5659 break; 5660 case NEWLINE: 5661 { 5662 setState(723); 5663 match(NEWLINE); 5664 } 5665 break; 5666 case LEADING_ASTERISK: 5667 { 5668 setState(724); 5669 match(LEADING_ASTERISK); 5670 } 5671 break; 5672 case WS: 5673 { 5674 setState(725); 5675 match(WS); 5676 } 5677 break; 5678 default: 5679 throw new NoViableAltException(this); 5680 } 5681 } 5682 setState(730); 5683 _errHandler.sync(this); 5684 _la = _input.LA(1); 5685 } 5686 setState(731); 5687 match(CLOSE); 5688 } 5689 } 5690 catch (RecognitionException re) { 5691 _localctx.exception = re; 5692 _errHandler.reportError(this, re); 5693 _errHandler.recover(this, re); 5694 } 5695 finally { 5696 exitRule(); 5697 } 5698 return _localctx; 5699 } 5700 5701 public static class ColgroupTagCloseContext extends ParserRuleContext { 5702 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5703 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5704 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5705 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5706 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5707 public TerminalNode NEWLINE(int i) { 5708 return getToken(JavadocParser.NEWLINE, i); 5709 } 5710 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5711 public TerminalNode LEADING_ASTERISK(int i) { 5712 return getToken(JavadocParser.LEADING_ASTERISK, i); 5713 } 5714 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5715 public TerminalNode WS(int i) { 5716 return getToken(JavadocParser.WS, i); 5717 } 5718 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5719 super(parent, invokingState); 5720 } 5721 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5722 @Override 5723 public void enterRule(ParseTreeListener listener) { 5724 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5725 } 5726 @Override 5727 public void exitRule(ParseTreeListener listener) { 5728 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5729 } 5730 @Override 5731 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5732 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5733 else return visitor.visitChildren(this); 5734 } 5735 } 5736 5737 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5738 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5739 enterRule(_localctx, 50, RULE_colgroupTagClose); 5740 int _la; 5741 try { 5742 enterOuterAlt(_localctx, 1); 5743 { 5744 setState(733); 5745 match(OPEN); 5746 setState(734); 5747 match(SLASH); 5748 setState(735); 5749 match(COLGROUP_HTML_TAG_NAME); 5750 setState(739); 5751 _errHandler.sync(this); 5752 _la = _input.LA(1); 5753 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5754 { 5755 { 5756 setState(736); 5757 _la = _input.LA(1); 5758 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5759 _errHandler.recoverInline(this); 5760 } 5761 else { 5762 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5763 _errHandler.reportMatch(this); 5764 consume(); 5765 } 5766 } 5767 } 5768 setState(741); 5769 _errHandler.sync(this); 5770 _la = _input.LA(1); 5771 } 5772 setState(742); 5773 match(CLOSE); 5774 } 5775 } 5776 catch (RecognitionException re) { 5777 _localctx.exception = re; 5778 _errHandler.reportError(this, re); 5779 _errHandler.recover(this, re); 5780 } 5781 finally { 5782 exitRule(); 5783 } 5784 return _localctx; 5785 } 5786 5787 public static class ColgroupContext extends ParserRuleContext { 5788 public ColgroupTagOpenContext colgroupTagOpen() { 5789 return getRuleContext(ColgroupTagOpenContext.class,0); 5790 } 5791 public ColgroupTagCloseContext colgroupTagClose() { 5792 return getRuleContext(ColgroupTagCloseContext.class,0); 5793 } 5794 public List<HtmlTagContext> htmlTag() { 5795 return getRuleContexts(HtmlTagContext.class); 5796 } 5797 public HtmlTagContext htmlTag(int i) { 5798 return getRuleContext(HtmlTagContext.class,i); 5799 } 5800 public List<SingletonTagContext> singletonTag() { 5801 return getRuleContexts(SingletonTagContext.class); 5802 } 5803 public SingletonTagContext singletonTag(int i) { 5804 return getRuleContext(SingletonTagContext.class,i); 5805 } 5806 public List<ParagraphContext> paragraph() { 5807 return getRuleContexts(ParagraphContext.class); 5808 } 5809 public ParagraphContext paragraph(int i) { 5810 return getRuleContext(ParagraphContext.class,i); 5811 } 5812 public List<LiContext> li() { 5813 return getRuleContexts(LiContext.class); 5814 } 5815 public LiContext li(int i) { 5816 return getRuleContext(LiContext.class,i); 5817 } 5818 public List<TrContext> tr() { 5819 return getRuleContexts(TrContext.class); 5820 } 5821 public TrContext tr(int i) { 5822 return getRuleContext(TrContext.class,i); 5823 } 5824 public List<TdContext> td() { 5825 return getRuleContexts(TdContext.class); 5826 } 5827 public TdContext td(int i) { 5828 return getRuleContext(TdContext.class,i); 5829 } 5830 public List<ThContext> th() { 5831 return getRuleContexts(ThContext.class); 5832 } 5833 public ThContext th(int i) { 5834 return getRuleContext(ThContext.class,i); 5835 } 5836 public List<BodyContext> body() { 5837 return getRuleContexts(BodyContext.class); 5838 } 5839 public BodyContext body(int i) { 5840 return getRuleContext(BodyContext.class,i); 5841 } 5842 public List<DdContext> dd() { 5843 return getRuleContexts(DdContext.class); 5844 } 5845 public DdContext dd(int i) { 5846 return getRuleContext(DdContext.class,i); 5847 } 5848 public List<DtContext> dt() { 5849 return getRuleContexts(DtContext.class); 5850 } 5851 public DtContext dt(int i) { 5852 return getRuleContext(DtContext.class,i); 5853 } 5854 public List<HeadContext> head() { 5855 return getRuleContexts(HeadContext.class); 5856 } 5857 public HeadContext head(int i) { 5858 return getRuleContext(HeadContext.class,i); 5859 } 5860 public List<HtmlContext> html() { 5861 return getRuleContexts(HtmlContext.class); 5862 } 5863 public HtmlContext html(int i) { 5864 return getRuleContext(HtmlContext.class,i); 5865 } 5866 public List<OptionContext> option() { 5867 return getRuleContexts(OptionContext.class); 5868 } 5869 public OptionContext option(int i) { 5870 return getRuleContext(OptionContext.class,i); 5871 } 5872 public List<TbodyContext> tbody() { 5873 return getRuleContexts(TbodyContext.class); 5874 } 5875 public TbodyContext tbody(int i) { 5876 return getRuleContext(TbodyContext.class,i); 5877 } 5878 public List<TheadContext> thead() { 5879 return getRuleContexts(TheadContext.class); 5880 } 5881 public TheadContext thead(int i) { 5882 return getRuleContext(TheadContext.class,i); 5883 } 5884 public List<TfootContext> tfoot() { 5885 return getRuleContexts(TfootContext.class); 5886 } 5887 public TfootContext tfoot(int i) { 5888 return getRuleContext(TfootContext.class,i); 5889 } 5890 public List<PTagOpenContext> pTagOpen() { 5891 return getRuleContexts(PTagOpenContext.class); 5892 } 5893 public PTagOpenContext pTagOpen(int i) { 5894 return getRuleContext(PTagOpenContext.class,i); 5895 } 5896 public List<LiTagOpenContext> liTagOpen() { 5897 return getRuleContexts(LiTagOpenContext.class); 5898 } 5899 public LiTagOpenContext liTagOpen(int i) { 5900 return getRuleContext(LiTagOpenContext.class,i); 5901 } 5902 public List<TrTagOpenContext> trTagOpen() { 5903 return getRuleContexts(TrTagOpenContext.class); 5904 } 5905 public TrTagOpenContext trTagOpen(int i) { 5906 return getRuleContext(TrTagOpenContext.class,i); 5907 } 5908 public List<TdTagOpenContext> tdTagOpen() { 5909 return getRuleContexts(TdTagOpenContext.class); 5910 } 5911 public TdTagOpenContext tdTagOpen(int i) { 5912 return getRuleContext(TdTagOpenContext.class,i); 5913 } 5914 public List<ThTagOpenContext> thTagOpen() { 5915 return getRuleContexts(ThTagOpenContext.class); 5916 } 5917 public ThTagOpenContext thTagOpen(int i) { 5918 return getRuleContext(ThTagOpenContext.class,i); 5919 } 5920 public List<BodyTagOpenContext> bodyTagOpen() { 5921 return getRuleContexts(BodyTagOpenContext.class); 5922 } 5923 public BodyTagOpenContext bodyTagOpen(int i) { 5924 return getRuleContext(BodyTagOpenContext.class,i); 5925 } 5926 public List<DdTagOpenContext> ddTagOpen() { 5927 return getRuleContexts(DdTagOpenContext.class); 5928 } 5929 public DdTagOpenContext ddTagOpen(int i) { 5930 return getRuleContext(DdTagOpenContext.class,i); 5931 } 5932 public List<DtTagOpenContext> dtTagOpen() { 5933 return getRuleContexts(DtTagOpenContext.class); 5934 } 5935 public DtTagOpenContext dtTagOpen(int i) { 5936 return getRuleContext(DtTagOpenContext.class,i); 5937 } 5938 public List<HeadTagOpenContext> headTagOpen() { 5939 return getRuleContexts(HeadTagOpenContext.class); 5940 } 5941 public HeadTagOpenContext headTagOpen(int i) { 5942 return getRuleContext(HeadTagOpenContext.class,i); 5943 } 5944 public List<HtmlTagOpenContext> htmlTagOpen() { 5945 return getRuleContexts(HtmlTagOpenContext.class); 5946 } 5947 public HtmlTagOpenContext htmlTagOpen(int i) { 5948 return getRuleContext(HtmlTagOpenContext.class,i); 5949 } 5950 public List<OptionTagOpenContext> optionTagOpen() { 5951 return getRuleContexts(OptionTagOpenContext.class); 5952 } 5953 public OptionTagOpenContext optionTagOpen(int i) { 5954 return getRuleContext(OptionTagOpenContext.class,i); 5955 } 5956 public List<TbodyTagOpenContext> tbodyTagOpen() { 5957 return getRuleContexts(TbodyTagOpenContext.class); 5958 } 5959 public TbodyTagOpenContext tbodyTagOpen(int i) { 5960 return getRuleContext(TbodyTagOpenContext.class,i); 5961 } 5962 public List<TheadTagOpenContext> theadTagOpen() { 5963 return getRuleContexts(TheadTagOpenContext.class); 5964 } 5965 public TheadTagOpenContext theadTagOpen(int i) { 5966 return getRuleContext(TheadTagOpenContext.class,i); 5967 } 5968 public List<TfootTagOpenContext> tfootTagOpen() { 5969 return getRuleContexts(TfootTagOpenContext.class); 5970 } 5971 public TfootTagOpenContext tfootTagOpen(int i) { 5972 return getRuleContext(TfootTagOpenContext.class,i); 5973 } 5974 public List<HtmlCommentContext> htmlComment() { 5975 return getRuleContexts(HtmlCommentContext.class); 5976 } 5977 public HtmlCommentContext htmlComment(int i) { 5978 return getRuleContext(HtmlCommentContext.class,i); 5979 } 5980 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5981 public TerminalNode CDATA(int i) { 5982 return getToken(JavadocParser.CDATA, i); 5983 } 5984 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5985 public TerminalNode NEWLINE(int i) { 5986 return getToken(JavadocParser.NEWLINE, i); 5987 } 5988 public List<TextContext> text() { 5989 return getRuleContexts(TextContext.class); 5990 } 5991 public TextContext text(int i) { 5992 return getRuleContext(TextContext.class,i); 5993 } 5994 public List<JavadocInlineTagContext> javadocInlineTag() { 5995 return getRuleContexts(JavadocInlineTagContext.class); 5996 } 5997 public JavadocInlineTagContext javadocInlineTag(int i) { 5998 return getRuleContext(JavadocInlineTagContext.class,i); 5999 } 6000 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6001 public TerminalNode LEADING_ASTERISK(int i) { 6002 return getToken(JavadocParser.LEADING_ASTERISK, i); 6003 } 6004 public ColgroupContext(ParserRuleContext parent, int invokingState) { 6005 super(parent, invokingState); 6006 } 6007 @Override public int getRuleIndex() { return RULE_colgroup; } 6008 @Override 6009 public void enterRule(ParseTreeListener listener) { 6010 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 6011 } 6012 @Override 6013 public void exitRule(ParseTreeListener listener) { 6014 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 6015 } 6016 @Override 6017 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6018 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 6019 else return visitor.visitChildren(this); 6020 } 6021 } 6022 6023 public final ColgroupContext colgroup() throws RecognitionException { 6024 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 6025 enterRule(_localctx, 52, RULE_colgroup); 6026 try { 6027 int _alt; 6028 enterOuterAlt(_localctx, 1); 6029 { 6030 setState(744); 6031 colgroupTagOpen(); 6032 setState(784); 6033 _errHandler.sync(this); 6034 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6035 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6036 if ( _alt==1 ) { 6037 { 6038 setState(782); 6039 _errHandler.sync(this); 6040 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 6041 case 1: 6042 { 6043 setState(745); 6044 htmlTag(); 6045 } 6046 break; 6047 case 2: 6048 { 6049 setState(746); 6050 singletonTag(); 6051 } 6052 break; 6053 case 3: 6054 { 6055 setState(747); 6056 paragraph(); 6057 } 6058 break; 6059 case 4: 6060 { 6061 setState(748); 6062 li(); 6063 } 6064 break; 6065 case 5: 6066 { 6067 setState(749); 6068 tr(); 6069 } 6070 break; 6071 case 6: 6072 { 6073 setState(750); 6074 td(); 6075 } 6076 break; 6077 case 7: 6078 { 6079 setState(751); 6080 th(); 6081 } 6082 break; 6083 case 8: 6084 { 6085 setState(752); 6086 body(); 6087 } 6088 break; 6089 case 9: 6090 { 6091 setState(753); 6092 dd(); 6093 } 6094 break; 6095 case 10: 6096 { 6097 setState(754); 6098 dt(); 6099 } 6100 break; 6101 case 11: 6102 { 6103 setState(755); 6104 head(); 6105 } 6106 break; 6107 case 12: 6108 { 6109 setState(756); 6110 html(); 6111 } 6112 break; 6113 case 13: 6114 { 6115 setState(757); 6116 option(); 6117 } 6118 break; 6119 case 14: 6120 { 6121 setState(758); 6122 tbody(); 6123 } 6124 break; 6125 case 15: 6126 { 6127 setState(759); 6128 thead(); 6129 } 6130 break; 6131 case 16: 6132 { 6133 setState(760); 6134 tfoot(); 6135 } 6136 break; 6137 case 17: 6138 { 6139 setState(761); 6140 pTagOpen(); 6141 } 6142 break; 6143 case 18: 6144 { 6145 setState(762); 6146 liTagOpen(); 6147 } 6148 break; 6149 case 19: 6150 { 6151 setState(763); 6152 trTagOpen(); 6153 } 6154 break; 6155 case 20: 6156 { 6157 setState(764); 6158 tdTagOpen(); 6159 } 6160 break; 6161 case 21: 6162 { 6163 setState(765); 6164 thTagOpen(); 6165 } 6166 break; 6167 case 22: 6168 { 6169 setState(766); 6170 bodyTagOpen(); 6171 } 6172 break; 6173 case 23: 6174 { 6175 setState(767); 6176 ddTagOpen(); 6177 } 6178 break; 6179 case 24: 6180 { 6181 setState(768); 6182 dtTagOpen(); 6183 } 6184 break; 6185 case 25: 6186 { 6187 setState(769); 6188 headTagOpen(); 6189 } 6190 break; 6191 case 26: 6192 { 6193 setState(770); 6194 htmlTagOpen(); 6195 } 6196 break; 6197 case 27: 6198 { 6199 setState(771); 6200 optionTagOpen(); 6201 } 6202 break; 6203 case 28: 6204 { 6205 setState(772); 6206 tbodyTagOpen(); 6207 } 6208 break; 6209 case 29: 6210 { 6211 setState(773); 6212 theadTagOpen(); 6213 } 6214 break; 6215 case 30: 6216 { 6217 setState(774); 6218 tfootTagOpen(); 6219 } 6220 break; 6221 case 31: 6222 { 6223 { 6224 setState(775); 6225 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6226 setState(776); 6227 match(LEADING_ASTERISK); 6228 } 6229 } 6230 break; 6231 case 32: 6232 { 6233 setState(777); 6234 htmlComment(); 6235 } 6236 break; 6237 case 33: 6238 { 6239 setState(778); 6240 match(CDATA); 6241 } 6242 break; 6243 case 34: 6244 { 6245 setState(779); 6246 match(NEWLINE); 6247 } 6248 break; 6249 case 35: 6250 { 6251 setState(780); 6252 text(); 6253 } 6254 break; 6255 case 36: 6256 { 6257 setState(781); 6258 javadocInlineTag(); 6259 } 6260 break; 6261 } 6262 } 6263 } 6264 setState(786); 6265 _errHandler.sync(this); 6266 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6267 } 6268 setState(787); 6269 colgroupTagClose(); 6270 } 6271 } 6272 catch (RecognitionException re) { 6273 _localctx.exception = re; 6274 _errHandler.reportError(this, re); 6275 _errHandler.recover(this, re); 6276 } 6277 finally { 6278 exitRule(); 6279 } 6280 return _localctx; 6281 } 6282 6283 public static class DdTagOpenContext extends ParserRuleContext { 6284 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6285 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6286 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6287 public List<AttributeContext> attribute() { 6288 return getRuleContexts(AttributeContext.class); 6289 } 6290 public AttributeContext attribute(int i) { 6291 return getRuleContext(AttributeContext.class,i); 6292 } 6293 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6294 public TerminalNode NEWLINE(int i) { 6295 return getToken(JavadocParser.NEWLINE, i); 6296 } 6297 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6298 public TerminalNode LEADING_ASTERISK(int i) { 6299 return getToken(JavadocParser.LEADING_ASTERISK, i); 6300 } 6301 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6302 public TerminalNode WS(int i) { 6303 return getToken(JavadocParser.WS, i); 6304 } 6305 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6306 super(parent, invokingState); 6307 } 6308 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6309 @Override 6310 public void enterRule(ParseTreeListener listener) { 6311 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6312 } 6313 @Override 6314 public void exitRule(ParseTreeListener listener) { 6315 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6316 } 6317 @Override 6318 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6319 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6320 else return visitor.visitChildren(this); 6321 } 6322 } 6323 6324 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6325 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6326 enterRule(_localctx, 54, RULE_ddTagOpen); 6327 int _la; 6328 try { 6329 enterOuterAlt(_localctx, 1); 6330 { 6331 setState(789); 6332 match(OPEN); 6333 setState(790); 6334 match(DD_HTML_TAG_NAME); 6335 setState(797); 6336 _errHandler.sync(this); 6337 _la = _input.LA(1); 6338 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6339 { 6340 setState(795); 6341 _errHandler.sync(this); 6342 switch (_input.LA(1)) { 6343 case HTML_TAG_NAME: 6344 { 6345 setState(791); 6346 attribute(); 6347 } 6348 break; 6349 case NEWLINE: 6350 { 6351 setState(792); 6352 match(NEWLINE); 6353 } 6354 break; 6355 case LEADING_ASTERISK: 6356 { 6357 setState(793); 6358 match(LEADING_ASTERISK); 6359 } 6360 break; 6361 case WS: 6362 { 6363 setState(794); 6364 match(WS); 6365 } 6366 break; 6367 default: 6368 throw new NoViableAltException(this); 6369 } 6370 } 6371 setState(799); 6372 _errHandler.sync(this); 6373 _la = _input.LA(1); 6374 } 6375 setState(800); 6376 match(CLOSE); 6377 } 6378 } 6379 catch (RecognitionException re) { 6380 _localctx.exception = re; 6381 _errHandler.reportError(this, re); 6382 _errHandler.recover(this, re); 6383 } 6384 finally { 6385 exitRule(); 6386 } 6387 return _localctx; 6388 } 6389 6390 public static class DdTagCloseContext extends ParserRuleContext { 6391 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6392 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6393 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6394 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6395 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6396 public TerminalNode NEWLINE(int i) { 6397 return getToken(JavadocParser.NEWLINE, i); 6398 } 6399 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6400 public TerminalNode LEADING_ASTERISK(int i) { 6401 return getToken(JavadocParser.LEADING_ASTERISK, i); 6402 } 6403 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6404 public TerminalNode WS(int i) { 6405 return getToken(JavadocParser.WS, i); 6406 } 6407 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6408 super(parent, invokingState); 6409 } 6410 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6411 @Override 6412 public void enterRule(ParseTreeListener listener) { 6413 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6414 } 6415 @Override 6416 public void exitRule(ParseTreeListener listener) { 6417 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6418 } 6419 @Override 6420 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6421 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6422 else return visitor.visitChildren(this); 6423 } 6424 } 6425 6426 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6427 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6428 enterRule(_localctx, 56, RULE_ddTagClose); 6429 int _la; 6430 try { 6431 enterOuterAlt(_localctx, 1); 6432 { 6433 setState(802); 6434 match(OPEN); 6435 setState(803); 6436 match(SLASH); 6437 setState(804); 6438 match(DD_HTML_TAG_NAME); 6439 setState(808); 6440 _errHandler.sync(this); 6441 _la = _input.LA(1); 6442 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6443 { 6444 { 6445 setState(805); 6446 _la = _input.LA(1); 6447 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6448 _errHandler.recoverInline(this); 6449 } 6450 else { 6451 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6452 _errHandler.reportMatch(this); 6453 consume(); 6454 } 6455 } 6456 } 6457 setState(810); 6458 _errHandler.sync(this); 6459 _la = _input.LA(1); 6460 } 6461 setState(811); 6462 match(CLOSE); 6463 } 6464 } 6465 catch (RecognitionException re) { 6466 _localctx.exception = re; 6467 _errHandler.reportError(this, re); 6468 _errHandler.recover(this, re); 6469 } 6470 finally { 6471 exitRule(); 6472 } 6473 return _localctx; 6474 } 6475 6476 public static class DdContext extends ParserRuleContext { 6477 public DdTagOpenContext ddTagOpen() { 6478 return getRuleContext(DdTagOpenContext.class,0); 6479 } 6480 public DdTagCloseContext ddTagClose() { 6481 return getRuleContext(DdTagCloseContext.class,0); 6482 } 6483 public List<HtmlTagContext> htmlTag() { 6484 return getRuleContexts(HtmlTagContext.class); 6485 } 6486 public HtmlTagContext htmlTag(int i) { 6487 return getRuleContext(HtmlTagContext.class,i); 6488 } 6489 public List<SingletonTagContext> singletonTag() { 6490 return getRuleContexts(SingletonTagContext.class); 6491 } 6492 public SingletonTagContext singletonTag(int i) { 6493 return getRuleContext(SingletonTagContext.class,i); 6494 } 6495 public List<ParagraphContext> paragraph() { 6496 return getRuleContexts(ParagraphContext.class); 6497 } 6498 public ParagraphContext paragraph(int i) { 6499 return getRuleContext(ParagraphContext.class,i); 6500 } 6501 public List<LiContext> li() { 6502 return getRuleContexts(LiContext.class); 6503 } 6504 public LiContext li(int i) { 6505 return getRuleContext(LiContext.class,i); 6506 } 6507 public List<TrContext> tr() { 6508 return getRuleContexts(TrContext.class); 6509 } 6510 public TrContext tr(int i) { 6511 return getRuleContext(TrContext.class,i); 6512 } 6513 public List<TdContext> td() { 6514 return getRuleContexts(TdContext.class); 6515 } 6516 public TdContext td(int i) { 6517 return getRuleContext(TdContext.class,i); 6518 } 6519 public List<ThContext> th() { 6520 return getRuleContexts(ThContext.class); 6521 } 6522 public ThContext th(int i) { 6523 return getRuleContext(ThContext.class,i); 6524 } 6525 public List<BodyContext> body() { 6526 return getRuleContexts(BodyContext.class); 6527 } 6528 public BodyContext body(int i) { 6529 return getRuleContext(BodyContext.class,i); 6530 } 6531 public List<ColgroupContext> colgroup() { 6532 return getRuleContexts(ColgroupContext.class); 6533 } 6534 public ColgroupContext colgroup(int i) { 6535 return getRuleContext(ColgroupContext.class,i); 6536 } 6537 public List<DtContext> dt() { 6538 return getRuleContexts(DtContext.class); 6539 } 6540 public DtContext dt(int i) { 6541 return getRuleContext(DtContext.class,i); 6542 } 6543 public List<HeadContext> head() { 6544 return getRuleContexts(HeadContext.class); 6545 } 6546 public HeadContext head(int i) { 6547 return getRuleContext(HeadContext.class,i); 6548 } 6549 public List<HtmlContext> html() { 6550 return getRuleContexts(HtmlContext.class); 6551 } 6552 public HtmlContext html(int i) { 6553 return getRuleContext(HtmlContext.class,i); 6554 } 6555 public List<OptionContext> option() { 6556 return getRuleContexts(OptionContext.class); 6557 } 6558 public OptionContext option(int i) { 6559 return getRuleContext(OptionContext.class,i); 6560 } 6561 public List<TbodyContext> tbody() { 6562 return getRuleContexts(TbodyContext.class); 6563 } 6564 public TbodyContext tbody(int i) { 6565 return getRuleContext(TbodyContext.class,i); 6566 } 6567 public List<TheadContext> thead() { 6568 return getRuleContexts(TheadContext.class); 6569 } 6570 public TheadContext thead(int i) { 6571 return getRuleContext(TheadContext.class,i); 6572 } 6573 public List<TfootContext> tfoot() { 6574 return getRuleContexts(TfootContext.class); 6575 } 6576 public TfootContext tfoot(int i) { 6577 return getRuleContext(TfootContext.class,i); 6578 } 6579 public List<PTagOpenContext> pTagOpen() { 6580 return getRuleContexts(PTagOpenContext.class); 6581 } 6582 public PTagOpenContext pTagOpen(int i) { 6583 return getRuleContext(PTagOpenContext.class,i); 6584 } 6585 public List<LiTagOpenContext> liTagOpen() { 6586 return getRuleContexts(LiTagOpenContext.class); 6587 } 6588 public LiTagOpenContext liTagOpen(int i) { 6589 return getRuleContext(LiTagOpenContext.class,i); 6590 } 6591 public List<TrTagOpenContext> trTagOpen() { 6592 return getRuleContexts(TrTagOpenContext.class); 6593 } 6594 public TrTagOpenContext trTagOpen(int i) { 6595 return getRuleContext(TrTagOpenContext.class,i); 6596 } 6597 public List<TdTagOpenContext> tdTagOpen() { 6598 return getRuleContexts(TdTagOpenContext.class); 6599 } 6600 public TdTagOpenContext tdTagOpen(int i) { 6601 return getRuleContext(TdTagOpenContext.class,i); 6602 } 6603 public List<ThTagOpenContext> thTagOpen() { 6604 return getRuleContexts(ThTagOpenContext.class); 6605 } 6606 public ThTagOpenContext thTagOpen(int i) { 6607 return getRuleContext(ThTagOpenContext.class,i); 6608 } 6609 public List<BodyTagOpenContext> bodyTagOpen() { 6610 return getRuleContexts(BodyTagOpenContext.class); 6611 } 6612 public BodyTagOpenContext bodyTagOpen(int i) { 6613 return getRuleContext(BodyTagOpenContext.class,i); 6614 } 6615 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6616 return getRuleContexts(ColgroupTagOpenContext.class); 6617 } 6618 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6619 return getRuleContext(ColgroupTagOpenContext.class,i); 6620 } 6621 public List<DtTagOpenContext> dtTagOpen() { 6622 return getRuleContexts(DtTagOpenContext.class); 6623 } 6624 public DtTagOpenContext dtTagOpen(int i) { 6625 return getRuleContext(DtTagOpenContext.class,i); 6626 } 6627 public List<HeadTagOpenContext> headTagOpen() { 6628 return getRuleContexts(HeadTagOpenContext.class); 6629 } 6630 public HeadTagOpenContext headTagOpen(int i) { 6631 return getRuleContext(HeadTagOpenContext.class,i); 6632 } 6633 public List<HtmlTagOpenContext> htmlTagOpen() { 6634 return getRuleContexts(HtmlTagOpenContext.class); 6635 } 6636 public HtmlTagOpenContext htmlTagOpen(int i) { 6637 return getRuleContext(HtmlTagOpenContext.class,i); 6638 } 6639 public List<OptionTagOpenContext> optionTagOpen() { 6640 return getRuleContexts(OptionTagOpenContext.class); 6641 } 6642 public OptionTagOpenContext optionTagOpen(int i) { 6643 return getRuleContext(OptionTagOpenContext.class,i); 6644 } 6645 public List<TbodyTagOpenContext> tbodyTagOpen() { 6646 return getRuleContexts(TbodyTagOpenContext.class); 6647 } 6648 public TbodyTagOpenContext tbodyTagOpen(int i) { 6649 return getRuleContext(TbodyTagOpenContext.class,i); 6650 } 6651 public List<TheadTagOpenContext> theadTagOpen() { 6652 return getRuleContexts(TheadTagOpenContext.class); 6653 } 6654 public TheadTagOpenContext theadTagOpen(int i) { 6655 return getRuleContext(TheadTagOpenContext.class,i); 6656 } 6657 public List<TfootTagOpenContext> tfootTagOpen() { 6658 return getRuleContexts(TfootTagOpenContext.class); 6659 } 6660 public TfootTagOpenContext tfootTagOpen(int i) { 6661 return getRuleContext(TfootTagOpenContext.class,i); 6662 } 6663 public List<HtmlCommentContext> htmlComment() { 6664 return getRuleContexts(HtmlCommentContext.class); 6665 } 6666 public HtmlCommentContext htmlComment(int i) { 6667 return getRuleContext(HtmlCommentContext.class,i); 6668 } 6669 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6670 public TerminalNode CDATA(int i) { 6671 return getToken(JavadocParser.CDATA, i); 6672 } 6673 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6674 public TerminalNode NEWLINE(int i) { 6675 return getToken(JavadocParser.NEWLINE, i); 6676 } 6677 public List<TextContext> text() { 6678 return getRuleContexts(TextContext.class); 6679 } 6680 public TextContext text(int i) { 6681 return getRuleContext(TextContext.class,i); 6682 } 6683 public List<JavadocInlineTagContext> javadocInlineTag() { 6684 return getRuleContexts(JavadocInlineTagContext.class); 6685 } 6686 public JavadocInlineTagContext javadocInlineTag(int i) { 6687 return getRuleContext(JavadocInlineTagContext.class,i); 6688 } 6689 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6690 public TerminalNode LEADING_ASTERISK(int i) { 6691 return getToken(JavadocParser.LEADING_ASTERISK, i); 6692 } 6693 public DdContext(ParserRuleContext parent, int invokingState) { 6694 super(parent, invokingState); 6695 } 6696 @Override public int getRuleIndex() { return RULE_dd; } 6697 @Override 6698 public void enterRule(ParseTreeListener listener) { 6699 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6700 } 6701 @Override 6702 public void exitRule(ParseTreeListener listener) { 6703 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6704 } 6705 @Override 6706 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6707 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6708 else return visitor.visitChildren(this); 6709 } 6710 } 6711 6712 public final DdContext dd() throws RecognitionException { 6713 DdContext _localctx = new DdContext(_ctx, getState()); 6714 enterRule(_localctx, 58, RULE_dd); 6715 try { 6716 int _alt; 6717 enterOuterAlt(_localctx, 1); 6718 { 6719 setState(813); 6720 ddTagOpen(); 6721 setState(853); 6722 _errHandler.sync(this); 6723 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6724 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6725 if ( _alt==1 ) { 6726 { 6727 setState(851); 6728 _errHandler.sync(this); 6729 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6730 case 1: 6731 { 6732 setState(814); 6733 htmlTag(); 6734 } 6735 break; 6736 case 2: 6737 { 6738 setState(815); 6739 singletonTag(); 6740 } 6741 break; 6742 case 3: 6743 { 6744 setState(816); 6745 paragraph(); 6746 } 6747 break; 6748 case 4: 6749 { 6750 setState(817); 6751 li(); 6752 } 6753 break; 6754 case 5: 6755 { 6756 setState(818); 6757 tr(); 6758 } 6759 break; 6760 case 6: 6761 { 6762 setState(819); 6763 td(); 6764 } 6765 break; 6766 case 7: 6767 { 6768 setState(820); 6769 th(); 6770 } 6771 break; 6772 case 8: 6773 { 6774 setState(821); 6775 body(); 6776 } 6777 break; 6778 case 9: 6779 { 6780 setState(822); 6781 colgroup(); 6782 } 6783 break; 6784 case 10: 6785 { 6786 setState(823); 6787 dt(); 6788 } 6789 break; 6790 case 11: 6791 { 6792 setState(824); 6793 head(); 6794 } 6795 break; 6796 case 12: 6797 { 6798 setState(825); 6799 html(); 6800 } 6801 break; 6802 case 13: 6803 { 6804 setState(826); 6805 option(); 6806 } 6807 break; 6808 case 14: 6809 { 6810 setState(827); 6811 tbody(); 6812 } 6813 break; 6814 case 15: 6815 { 6816 setState(828); 6817 thead(); 6818 } 6819 break; 6820 case 16: 6821 { 6822 setState(829); 6823 tfoot(); 6824 } 6825 break; 6826 case 17: 6827 { 6828 setState(830); 6829 pTagOpen(); 6830 } 6831 break; 6832 case 18: 6833 { 6834 setState(831); 6835 liTagOpen(); 6836 } 6837 break; 6838 case 19: 6839 { 6840 setState(832); 6841 trTagOpen(); 6842 } 6843 break; 6844 case 20: 6845 { 6846 setState(833); 6847 tdTagOpen(); 6848 } 6849 break; 6850 case 21: 6851 { 6852 setState(834); 6853 thTagOpen(); 6854 } 6855 break; 6856 case 22: 6857 { 6858 setState(835); 6859 bodyTagOpen(); 6860 } 6861 break; 6862 case 23: 6863 { 6864 setState(836); 6865 colgroupTagOpen(); 6866 } 6867 break; 6868 case 24: 6869 { 6870 setState(837); 6871 dtTagOpen(); 6872 } 6873 break; 6874 case 25: 6875 { 6876 setState(838); 6877 headTagOpen(); 6878 } 6879 break; 6880 case 26: 6881 { 6882 setState(839); 6883 htmlTagOpen(); 6884 } 6885 break; 6886 case 27: 6887 { 6888 setState(840); 6889 optionTagOpen(); 6890 } 6891 break; 6892 case 28: 6893 { 6894 setState(841); 6895 tbodyTagOpen(); 6896 } 6897 break; 6898 case 29: 6899 { 6900 setState(842); 6901 theadTagOpen(); 6902 } 6903 break; 6904 case 30: 6905 { 6906 setState(843); 6907 tfootTagOpen(); 6908 } 6909 break; 6910 case 31: 6911 { 6912 { 6913 setState(844); 6914 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6915 setState(845); 6916 match(LEADING_ASTERISK); 6917 } 6918 } 6919 break; 6920 case 32: 6921 { 6922 setState(846); 6923 htmlComment(); 6924 } 6925 break; 6926 case 33: 6927 { 6928 setState(847); 6929 match(CDATA); 6930 } 6931 break; 6932 case 34: 6933 { 6934 setState(848); 6935 match(NEWLINE); 6936 } 6937 break; 6938 case 35: 6939 { 6940 setState(849); 6941 text(); 6942 } 6943 break; 6944 case 36: 6945 { 6946 setState(850); 6947 javadocInlineTag(); 6948 } 6949 break; 6950 } 6951 } 6952 } 6953 setState(855); 6954 _errHandler.sync(this); 6955 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6956 } 6957 setState(856); 6958 ddTagClose(); 6959 } 6960 } 6961 catch (RecognitionException re) { 6962 _localctx.exception = re; 6963 _errHandler.reportError(this, re); 6964 _errHandler.recover(this, re); 6965 } 6966 finally { 6967 exitRule(); 6968 } 6969 return _localctx; 6970 } 6971 6972 public static class DtTagOpenContext extends ParserRuleContext { 6973 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6974 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6975 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6976 public List<AttributeContext> attribute() { 6977 return getRuleContexts(AttributeContext.class); 6978 } 6979 public AttributeContext attribute(int i) { 6980 return getRuleContext(AttributeContext.class,i); 6981 } 6982 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6983 public TerminalNode NEWLINE(int i) { 6984 return getToken(JavadocParser.NEWLINE, i); 6985 } 6986 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6987 public TerminalNode LEADING_ASTERISK(int i) { 6988 return getToken(JavadocParser.LEADING_ASTERISK, i); 6989 } 6990 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6991 public TerminalNode WS(int i) { 6992 return getToken(JavadocParser.WS, i); 6993 } 6994 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6995 super(parent, invokingState); 6996 } 6997 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6998 @Override 6999 public void enterRule(ParseTreeListener listener) { 7000 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 7001 } 7002 @Override 7003 public void exitRule(ParseTreeListener listener) { 7004 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 7005 } 7006 @Override 7007 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7008 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 7009 else return visitor.visitChildren(this); 7010 } 7011 } 7012 7013 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 7014 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 7015 enterRule(_localctx, 60, RULE_dtTagOpen); 7016 int _la; 7017 try { 7018 enterOuterAlt(_localctx, 1); 7019 { 7020 setState(858); 7021 match(OPEN); 7022 setState(859); 7023 match(DT_HTML_TAG_NAME); 7024 setState(866); 7025 _errHandler.sync(this); 7026 _la = _input.LA(1); 7027 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7028 { 7029 setState(864); 7030 _errHandler.sync(this); 7031 switch (_input.LA(1)) { 7032 case HTML_TAG_NAME: 7033 { 7034 setState(860); 7035 attribute(); 7036 } 7037 break; 7038 case NEWLINE: 7039 { 7040 setState(861); 7041 match(NEWLINE); 7042 } 7043 break; 7044 case LEADING_ASTERISK: 7045 { 7046 setState(862); 7047 match(LEADING_ASTERISK); 7048 } 7049 break; 7050 case WS: 7051 { 7052 setState(863); 7053 match(WS); 7054 } 7055 break; 7056 default: 7057 throw new NoViableAltException(this); 7058 } 7059 } 7060 setState(868); 7061 _errHandler.sync(this); 7062 _la = _input.LA(1); 7063 } 7064 setState(869); 7065 match(CLOSE); 7066 } 7067 } 7068 catch (RecognitionException re) { 7069 _localctx.exception = re; 7070 _errHandler.reportError(this, re); 7071 _errHandler.recover(this, re); 7072 } 7073 finally { 7074 exitRule(); 7075 } 7076 return _localctx; 7077 } 7078 7079 public static class DtTagCloseContext extends ParserRuleContext { 7080 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7081 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7082 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7083 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7084 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7085 public TerminalNode NEWLINE(int i) { 7086 return getToken(JavadocParser.NEWLINE, i); 7087 } 7088 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7089 public TerminalNode LEADING_ASTERISK(int i) { 7090 return getToken(JavadocParser.LEADING_ASTERISK, i); 7091 } 7092 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7093 public TerminalNode WS(int i) { 7094 return getToken(JavadocParser.WS, i); 7095 } 7096 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7097 super(parent, invokingState); 7098 } 7099 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7100 @Override 7101 public void enterRule(ParseTreeListener listener) { 7102 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7103 } 7104 @Override 7105 public void exitRule(ParseTreeListener listener) { 7106 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7107 } 7108 @Override 7109 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7110 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7111 else return visitor.visitChildren(this); 7112 } 7113 } 7114 7115 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7116 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7117 enterRule(_localctx, 62, RULE_dtTagClose); 7118 int _la; 7119 try { 7120 enterOuterAlt(_localctx, 1); 7121 { 7122 setState(871); 7123 match(OPEN); 7124 setState(872); 7125 match(SLASH); 7126 setState(873); 7127 match(DT_HTML_TAG_NAME); 7128 setState(877); 7129 _errHandler.sync(this); 7130 _la = _input.LA(1); 7131 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7132 { 7133 { 7134 setState(874); 7135 _la = _input.LA(1); 7136 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7137 _errHandler.recoverInline(this); 7138 } 7139 else { 7140 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7141 _errHandler.reportMatch(this); 7142 consume(); 7143 } 7144 } 7145 } 7146 setState(879); 7147 _errHandler.sync(this); 7148 _la = _input.LA(1); 7149 } 7150 setState(880); 7151 match(CLOSE); 7152 } 7153 } 7154 catch (RecognitionException re) { 7155 _localctx.exception = re; 7156 _errHandler.reportError(this, re); 7157 _errHandler.recover(this, re); 7158 } 7159 finally { 7160 exitRule(); 7161 } 7162 return _localctx; 7163 } 7164 7165 public static class DtContext extends ParserRuleContext { 7166 public DtTagOpenContext dtTagOpen() { 7167 return getRuleContext(DtTagOpenContext.class,0); 7168 } 7169 public DtTagCloseContext dtTagClose() { 7170 return getRuleContext(DtTagCloseContext.class,0); 7171 } 7172 public List<HtmlTagContext> htmlTag() { 7173 return getRuleContexts(HtmlTagContext.class); 7174 } 7175 public HtmlTagContext htmlTag(int i) { 7176 return getRuleContext(HtmlTagContext.class,i); 7177 } 7178 public List<SingletonTagContext> singletonTag() { 7179 return getRuleContexts(SingletonTagContext.class); 7180 } 7181 public SingletonTagContext singletonTag(int i) { 7182 return getRuleContext(SingletonTagContext.class,i); 7183 } 7184 public List<ParagraphContext> paragraph() { 7185 return getRuleContexts(ParagraphContext.class); 7186 } 7187 public ParagraphContext paragraph(int i) { 7188 return getRuleContext(ParagraphContext.class,i); 7189 } 7190 public List<LiContext> li() { 7191 return getRuleContexts(LiContext.class); 7192 } 7193 public LiContext li(int i) { 7194 return getRuleContext(LiContext.class,i); 7195 } 7196 public List<TrContext> tr() { 7197 return getRuleContexts(TrContext.class); 7198 } 7199 public TrContext tr(int i) { 7200 return getRuleContext(TrContext.class,i); 7201 } 7202 public List<TdContext> td() { 7203 return getRuleContexts(TdContext.class); 7204 } 7205 public TdContext td(int i) { 7206 return getRuleContext(TdContext.class,i); 7207 } 7208 public List<ThContext> th() { 7209 return getRuleContexts(ThContext.class); 7210 } 7211 public ThContext th(int i) { 7212 return getRuleContext(ThContext.class,i); 7213 } 7214 public List<BodyContext> body() { 7215 return getRuleContexts(BodyContext.class); 7216 } 7217 public BodyContext body(int i) { 7218 return getRuleContext(BodyContext.class,i); 7219 } 7220 public List<ColgroupContext> colgroup() { 7221 return getRuleContexts(ColgroupContext.class); 7222 } 7223 public ColgroupContext colgroup(int i) { 7224 return getRuleContext(ColgroupContext.class,i); 7225 } 7226 public List<DdContext> dd() { 7227 return getRuleContexts(DdContext.class); 7228 } 7229 public DdContext dd(int i) { 7230 return getRuleContext(DdContext.class,i); 7231 } 7232 public List<HeadContext> head() { 7233 return getRuleContexts(HeadContext.class); 7234 } 7235 public HeadContext head(int i) { 7236 return getRuleContext(HeadContext.class,i); 7237 } 7238 public List<HtmlContext> html() { 7239 return getRuleContexts(HtmlContext.class); 7240 } 7241 public HtmlContext html(int i) { 7242 return getRuleContext(HtmlContext.class,i); 7243 } 7244 public List<OptionContext> option() { 7245 return getRuleContexts(OptionContext.class); 7246 } 7247 public OptionContext option(int i) { 7248 return getRuleContext(OptionContext.class,i); 7249 } 7250 public List<TbodyContext> tbody() { 7251 return getRuleContexts(TbodyContext.class); 7252 } 7253 public TbodyContext tbody(int i) { 7254 return getRuleContext(TbodyContext.class,i); 7255 } 7256 public List<TheadContext> thead() { 7257 return getRuleContexts(TheadContext.class); 7258 } 7259 public TheadContext thead(int i) { 7260 return getRuleContext(TheadContext.class,i); 7261 } 7262 public List<TfootContext> tfoot() { 7263 return getRuleContexts(TfootContext.class); 7264 } 7265 public TfootContext tfoot(int i) { 7266 return getRuleContext(TfootContext.class,i); 7267 } 7268 public List<PTagOpenContext> pTagOpen() { 7269 return getRuleContexts(PTagOpenContext.class); 7270 } 7271 public PTagOpenContext pTagOpen(int i) { 7272 return getRuleContext(PTagOpenContext.class,i); 7273 } 7274 public List<LiTagOpenContext> liTagOpen() { 7275 return getRuleContexts(LiTagOpenContext.class); 7276 } 7277 public LiTagOpenContext liTagOpen(int i) { 7278 return getRuleContext(LiTagOpenContext.class,i); 7279 } 7280 public List<TrTagOpenContext> trTagOpen() { 7281 return getRuleContexts(TrTagOpenContext.class); 7282 } 7283 public TrTagOpenContext trTagOpen(int i) { 7284 return getRuleContext(TrTagOpenContext.class,i); 7285 } 7286 public List<TdTagOpenContext> tdTagOpen() { 7287 return getRuleContexts(TdTagOpenContext.class); 7288 } 7289 public TdTagOpenContext tdTagOpen(int i) { 7290 return getRuleContext(TdTagOpenContext.class,i); 7291 } 7292 public List<ThTagOpenContext> thTagOpen() { 7293 return getRuleContexts(ThTagOpenContext.class); 7294 } 7295 public ThTagOpenContext thTagOpen(int i) { 7296 return getRuleContext(ThTagOpenContext.class,i); 7297 } 7298 public List<BodyTagOpenContext> bodyTagOpen() { 7299 return getRuleContexts(BodyTagOpenContext.class); 7300 } 7301 public BodyTagOpenContext bodyTagOpen(int i) { 7302 return getRuleContext(BodyTagOpenContext.class,i); 7303 } 7304 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7305 return getRuleContexts(ColgroupTagOpenContext.class); 7306 } 7307 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7308 return getRuleContext(ColgroupTagOpenContext.class,i); 7309 } 7310 public List<DdTagOpenContext> ddTagOpen() { 7311 return getRuleContexts(DdTagOpenContext.class); 7312 } 7313 public DdTagOpenContext ddTagOpen(int i) { 7314 return getRuleContext(DdTagOpenContext.class,i); 7315 } 7316 public List<HeadTagOpenContext> headTagOpen() { 7317 return getRuleContexts(HeadTagOpenContext.class); 7318 } 7319 public HeadTagOpenContext headTagOpen(int i) { 7320 return getRuleContext(HeadTagOpenContext.class,i); 7321 } 7322 public List<HtmlTagOpenContext> htmlTagOpen() { 7323 return getRuleContexts(HtmlTagOpenContext.class); 7324 } 7325 public HtmlTagOpenContext htmlTagOpen(int i) { 7326 return getRuleContext(HtmlTagOpenContext.class,i); 7327 } 7328 public List<OptionTagOpenContext> optionTagOpen() { 7329 return getRuleContexts(OptionTagOpenContext.class); 7330 } 7331 public OptionTagOpenContext optionTagOpen(int i) { 7332 return getRuleContext(OptionTagOpenContext.class,i); 7333 } 7334 public List<TbodyTagOpenContext> tbodyTagOpen() { 7335 return getRuleContexts(TbodyTagOpenContext.class); 7336 } 7337 public TbodyTagOpenContext tbodyTagOpen(int i) { 7338 return getRuleContext(TbodyTagOpenContext.class,i); 7339 } 7340 public List<TheadTagOpenContext> theadTagOpen() { 7341 return getRuleContexts(TheadTagOpenContext.class); 7342 } 7343 public TheadTagOpenContext theadTagOpen(int i) { 7344 return getRuleContext(TheadTagOpenContext.class,i); 7345 } 7346 public List<TfootTagOpenContext> tfootTagOpen() { 7347 return getRuleContexts(TfootTagOpenContext.class); 7348 } 7349 public TfootTagOpenContext tfootTagOpen(int i) { 7350 return getRuleContext(TfootTagOpenContext.class,i); 7351 } 7352 public List<HtmlCommentContext> htmlComment() { 7353 return getRuleContexts(HtmlCommentContext.class); 7354 } 7355 public HtmlCommentContext htmlComment(int i) { 7356 return getRuleContext(HtmlCommentContext.class,i); 7357 } 7358 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7359 public TerminalNode CDATA(int i) { 7360 return getToken(JavadocParser.CDATA, i); 7361 } 7362 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7363 public TerminalNode NEWLINE(int i) { 7364 return getToken(JavadocParser.NEWLINE, i); 7365 } 7366 public List<TextContext> text() { 7367 return getRuleContexts(TextContext.class); 7368 } 7369 public TextContext text(int i) { 7370 return getRuleContext(TextContext.class,i); 7371 } 7372 public List<JavadocInlineTagContext> javadocInlineTag() { 7373 return getRuleContexts(JavadocInlineTagContext.class); 7374 } 7375 public JavadocInlineTagContext javadocInlineTag(int i) { 7376 return getRuleContext(JavadocInlineTagContext.class,i); 7377 } 7378 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7379 public TerminalNode LEADING_ASTERISK(int i) { 7380 return getToken(JavadocParser.LEADING_ASTERISK, i); 7381 } 7382 public DtContext(ParserRuleContext parent, int invokingState) { 7383 super(parent, invokingState); 7384 } 7385 @Override public int getRuleIndex() { return RULE_dt; } 7386 @Override 7387 public void enterRule(ParseTreeListener listener) { 7388 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7389 } 7390 @Override 7391 public void exitRule(ParseTreeListener listener) { 7392 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7393 } 7394 @Override 7395 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7396 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7397 else return visitor.visitChildren(this); 7398 } 7399 } 7400 7401 public final DtContext dt() throws RecognitionException { 7402 DtContext _localctx = new DtContext(_ctx, getState()); 7403 enterRule(_localctx, 64, RULE_dt); 7404 try { 7405 int _alt; 7406 enterOuterAlt(_localctx, 1); 7407 { 7408 setState(882); 7409 dtTagOpen(); 7410 setState(922); 7411 _errHandler.sync(this); 7412 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7413 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7414 if ( _alt==1 ) { 7415 { 7416 setState(920); 7417 _errHandler.sync(this); 7418 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7419 case 1: 7420 { 7421 setState(883); 7422 htmlTag(); 7423 } 7424 break; 7425 case 2: 7426 { 7427 setState(884); 7428 singletonTag(); 7429 } 7430 break; 7431 case 3: 7432 { 7433 setState(885); 7434 paragraph(); 7435 } 7436 break; 7437 case 4: 7438 { 7439 setState(886); 7440 li(); 7441 } 7442 break; 7443 case 5: 7444 { 7445 setState(887); 7446 tr(); 7447 } 7448 break; 7449 case 6: 7450 { 7451 setState(888); 7452 td(); 7453 } 7454 break; 7455 case 7: 7456 { 7457 setState(889); 7458 th(); 7459 } 7460 break; 7461 case 8: 7462 { 7463 setState(890); 7464 body(); 7465 } 7466 break; 7467 case 9: 7468 { 7469 setState(891); 7470 colgroup(); 7471 } 7472 break; 7473 case 10: 7474 { 7475 setState(892); 7476 dd(); 7477 } 7478 break; 7479 case 11: 7480 { 7481 setState(893); 7482 head(); 7483 } 7484 break; 7485 case 12: 7486 { 7487 setState(894); 7488 html(); 7489 } 7490 break; 7491 case 13: 7492 { 7493 setState(895); 7494 option(); 7495 } 7496 break; 7497 case 14: 7498 { 7499 setState(896); 7500 tbody(); 7501 } 7502 break; 7503 case 15: 7504 { 7505 setState(897); 7506 thead(); 7507 } 7508 break; 7509 case 16: 7510 { 7511 setState(898); 7512 tfoot(); 7513 } 7514 break; 7515 case 17: 7516 { 7517 setState(899); 7518 pTagOpen(); 7519 } 7520 break; 7521 case 18: 7522 { 7523 setState(900); 7524 liTagOpen(); 7525 } 7526 break; 7527 case 19: 7528 { 7529 setState(901); 7530 trTagOpen(); 7531 } 7532 break; 7533 case 20: 7534 { 7535 setState(902); 7536 tdTagOpen(); 7537 } 7538 break; 7539 case 21: 7540 { 7541 setState(903); 7542 thTagOpen(); 7543 } 7544 break; 7545 case 22: 7546 { 7547 setState(904); 7548 bodyTagOpen(); 7549 } 7550 break; 7551 case 23: 7552 { 7553 setState(905); 7554 colgroupTagOpen(); 7555 } 7556 break; 7557 case 24: 7558 { 7559 setState(906); 7560 ddTagOpen(); 7561 } 7562 break; 7563 case 25: 7564 { 7565 setState(907); 7566 headTagOpen(); 7567 } 7568 break; 7569 case 26: 7570 { 7571 setState(908); 7572 htmlTagOpen(); 7573 } 7574 break; 7575 case 27: 7576 { 7577 setState(909); 7578 optionTagOpen(); 7579 } 7580 break; 7581 case 28: 7582 { 7583 setState(910); 7584 tbodyTagOpen(); 7585 } 7586 break; 7587 case 29: 7588 { 7589 setState(911); 7590 theadTagOpen(); 7591 } 7592 break; 7593 case 30: 7594 { 7595 setState(912); 7596 tfootTagOpen(); 7597 } 7598 break; 7599 case 31: 7600 { 7601 { 7602 setState(913); 7603 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7604 setState(914); 7605 match(LEADING_ASTERISK); 7606 } 7607 } 7608 break; 7609 case 32: 7610 { 7611 setState(915); 7612 htmlComment(); 7613 } 7614 break; 7615 case 33: 7616 { 7617 setState(916); 7618 match(CDATA); 7619 } 7620 break; 7621 case 34: 7622 { 7623 setState(917); 7624 match(NEWLINE); 7625 } 7626 break; 7627 case 35: 7628 { 7629 setState(918); 7630 text(); 7631 } 7632 break; 7633 case 36: 7634 { 7635 setState(919); 7636 javadocInlineTag(); 7637 } 7638 break; 7639 } 7640 } 7641 } 7642 setState(924); 7643 _errHandler.sync(this); 7644 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7645 } 7646 setState(925); 7647 dtTagClose(); 7648 } 7649 } 7650 catch (RecognitionException re) { 7651 _localctx.exception = re; 7652 _errHandler.reportError(this, re); 7653 _errHandler.recover(this, re); 7654 } 7655 finally { 7656 exitRule(); 7657 } 7658 return _localctx; 7659 } 7660 7661 public static class HeadTagOpenContext extends ParserRuleContext { 7662 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7663 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7664 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7665 public List<AttributeContext> attribute() { 7666 return getRuleContexts(AttributeContext.class); 7667 } 7668 public AttributeContext attribute(int i) { 7669 return getRuleContext(AttributeContext.class,i); 7670 } 7671 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7672 public TerminalNode NEWLINE(int i) { 7673 return getToken(JavadocParser.NEWLINE, i); 7674 } 7675 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7676 public TerminalNode LEADING_ASTERISK(int i) { 7677 return getToken(JavadocParser.LEADING_ASTERISK, i); 7678 } 7679 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7680 public TerminalNode WS(int i) { 7681 return getToken(JavadocParser.WS, i); 7682 } 7683 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7684 super(parent, invokingState); 7685 } 7686 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7687 @Override 7688 public void enterRule(ParseTreeListener listener) { 7689 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7690 } 7691 @Override 7692 public void exitRule(ParseTreeListener listener) { 7693 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7694 } 7695 @Override 7696 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7697 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7698 else return visitor.visitChildren(this); 7699 } 7700 } 7701 7702 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7703 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7704 enterRule(_localctx, 66, RULE_headTagOpen); 7705 int _la; 7706 try { 7707 enterOuterAlt(_localctx, 1); 7708 { 7709 setState(927); 7710 match(OPEN); 7711 setState(928); 7712 match(HEAD_HTML_TAG_NAME); 7713 setState(935); 7714 _errHandler.sync(this); 7715 _la = _input.LA(1); 7716 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7717 { 7718 setState(933); 7719 _errHandler.sync(this); 7720 switch (_input.LA(1)) { 7721 case HTML_TAG_NAME: 7722 { 7723 setState(929); 7724 attribute(); 7725 } 7726 break; 7727 case NEWLINE: 7728 { 7729 setState(930); 7730 match(NEWLINE); 7731 } 7732 break; 7733 case LEADING_ASTERISK: 7734 { 7735 setState(931); 7736 match(LEADING_ASTERISK); 7737 } 7738 break; 7739 case WS: 7740 { 7741 setState(932); 7742 match(WS); 7743 } 7744 break; 7745 default: 7746 throw new NoViableAltException(this); 7747 } 7748 } 7749 setState(937); 7750 _errHandler.sync(this); 7751 _la = _input.LA(1); 7752 } 7753 setState(938); 7754 match(CLOSE); 7755 } 7756 } 7757 catch (RecognitionException re) { 7758 _localctx.exception = re; 7759 _errHandler.reportError(this, re); 7760 _errHandler.recover(this, re); 7761 } 7762 finally { 7763 exitRule(); 7764 } 7765 return _localctx; 7766 } 7767 7768 public static class HeadTagCloseContext extends ParserRuleContext { 7769 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7770 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7771 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7772 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7773 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7774 public TerminalNode NEWLINE(int i) { 7775 return getToken(JavadocParser.NEWLINE, i); 7776 } 7777 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7778 public TerminalNode LEADING_ASTERISK(int i) { 7779 return getToken(JavadocParser.LEADING_ASTERISK, i); 7780 } 7781 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7782 public TerminalNode WS(int i) { 7783 return getToken(JavadocParser.WS, i); 7784 } 7785 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7786 super(parent, invokingState); 7787 } 7788 @Override public int getRuleIndex() { return RULE_headTagClose; } 7789 @Override 7790 public void enterRule(ParseTreeListener listener) { 7791 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7792 } 7793 @Override 7794 public void exitRule(ParseTreeListener listener) { 7795 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7796 } 7797 @Override 7798 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7799 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7800 else return visitor.visitChildren(this); 7801 } 7802 } 7803 7804 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7805 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7806 enterRule(_localctx, 68, RULE_headTagClose); 7807 int _la; 7808 try { 7809 enterOuterAlt(_localctx, 1); 7810 { 7811 setState(940); 7812 match(OPEN); 7813 setState(941); 7814 match(SLASH); 7815 setState(942); 7816 match(HEAD_HTML_TAG_NAME); 7817 setState(946); 7818 _errHandler.sync(this); 7819 _la = _input.LA(1); 7820 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7821 { 7822 { 7823 setState(943); 7824 _la = _input.LA(1); 7825 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7826 _errHandler.recoverInline(this); 7827 } 7828 else { 7829 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7830 _errHandler.reportMatch(this); 7831 consume(); 7832 } 7833 } 7834 } 7835 setState(948); 7836 _errHandler.sync(this); 7837 _la = _input.LA(1); 7838 } 7839 setState(949); 7840 match(CLOSE); 7841 } 7842 } 7843 catch (RecognitionException re) { 7844 _localctx.exception = re; 7845 _errHandler.reportError(this, re); 7846 _errHandler.recover(this, re); 7847 } 7848 finally { 7849 exitRule(); 7850 } 7851 return _localctx; 7852 } 7853 7854 public static class HeadContext extends ParserRuleContext { 7855 public HeadTagOpenContext headTagOpen() { 7856 return getRuleContext(HeadTagOpenContext.class,0); 7857 } 7858 public HeadTagCloseContext headTagClose() { 7859 return getRuleContext(HeadTagCloseContext.class,0); 7860 } 7861 public List<HtmlTagContext> htmlTag() { 7862 return getRuleContexts(HtmlTagContext.class); 7863 } 7864 public HtmlTagContext htmlTag(int i) { 7865 return getRuleContext(HtmlTagContext.class,i); 7866 } 7867 public List<SingletonTagContext> singletonTag() { 7868 return getRuleContexts(SingletonTagContext.class); 7869 } 7870 public SingletonTagContext singletonTag(int i) { 7871 return getRuleContext(SingletonTagContext.class,i); 7872 } 7873 public List<ParagraphContext> paragraph() { 7874 return getRuleContexts(ParagraphContext.class); 7875 } 7876 public ParagraphContext paragraph(int i) { 7877 return getRuleContext(ParagraphContext.class,i); 7878 } 7879 public List<LiContext> li() { 7880 return getRuleContexts(LiContext.class); 7881 } 7882 public LiContext li(int i) { 7883 return getRuleContext(LiContext.class,i); 7884 } 7885 public List<TrContext> tr() { 7886 return getRuleContexts(TrContext.class); 7887 } 7888 public TrContext tr(int i) { 7889 return getRuleContext(TrContext.class,i); 7890 } 7891 public List<TdContext> td() { 7892 return getRuleContexts(TdContext.class); 7893 } 7894 public TdContext td(int i) { 7895 return getRuleContext(TdContext.class,i); 7896 } 7897 public List<ThContext> th() { 7898 return getRuleContexts(ThContext.class); 7899 } 7900 public ThContext th(int i) { 7901 return getRuleContext(ThContext.class,i); 7902 } 7903 public List<BodyContext> body() { 7904 return getRuleContexts(BodyContext.class); 7905 } 7906 public BodyContext body(int i) { 7907 return getRuleContext(BodyContext.class,i); 7908 } 7909 public List<ColgroupContext> colgroup() { 7910 return getRuleContexts(ColgroupContext.class); 7911 } 7912 public ColgroupContext colgroup(int i) { 7913 return getRuleContext(ColgroupContext.class,i); 7914 } 7915 public List<DdContext> dd() { 7916 return getRuleContexts(DdContext.class); 7917 } 7918 public DdContext dd(int i) { 7919 return getRuleContext(DdContext.class,i); 7920 } 7921 public List<DtContext> dt() { 7922 return getRuleContexts(DtContext.class); 7923 } 7924 public DtContext dt(int i) { 7925 return getRuleContext(DtContext.class,i); 7926 } 7927 public List<HtmlContext> html() { 7928 return getRuleContexts(HtmlContext.class); 7929 } 7930 public HtmlContext html(int i) { 7931 return getRuleContext(HtmlContext.class,i); 7932 } 7933 public List<OptionContext> option() { 7934 return getRuleContexts(OptionContext.class); 7935 } 7936 public OptionContext option(int i) { 7937 return getRuleContext(OptionContext.class,i); 7938 } 7939 public List<TbodyContext> tbody() { 7940 return getRuleContexts(TbodyContext.class); 7941 } 7942 public TbodyContext tbody(int i) { 7943 return getRuleContext(TbodyContext.class,i); 7944 } 7945 public List<TheadContext> thead() { 7946 return getRuleContexts(TheadContext.class); 7947 } 7948 public TheadContext thead(int i) { 7949 return getRuleContext(TheadContext.class,i); 7950 } 7951 public List<TfootContext> tfoot() { 7952 return getRuleContexts(TfootContext.class); 7953 } 7954 public TfootContext tfoot(int i) { 7955 return getRuleContext(TfootContext.class,i); 7956 } 7957 public List<PTagOpenContext> pTagOpen() { 7958 return getRuleContexts(PTagOpenContext.class); 7959 } 7960 public PTagOpenContext pTagOpen(int i) { 7961 return getRuleContext(PTagOpenContext.class,i); 7962 } 7963 public List<LiTagOpenContext> liTagOpen() { 7964 return getRuleContexts(LiTagOpenContext.class); 7965 } 7966 public LiTagOpenContext liTagOpen(int i) { 7967 return getRuleContext(LiTagOpenContext.class,i); 7968 } 7969 public List<TrTagOpenContext> trTagOpen() { 7970 return getRuleContexts(TrTagOpenContext.class); 7971 } 7972 public TrTagOpenContext trTagOpen(int i) { 7973 return getRuleContext(TrTagOpenContext.class,i); 7974 } 7975 public List<TdTagOpenContext> tdTagOpen() { 7976 return getRuleContexts(TdTagOpenContext.class); 7977 } 7978 public TdTagOpenContext tdTagOpen(int i) { 7979 return getRuleContext(TdTagOpenContext.class,i); 7980 } 7981 public List<ThTagOpenContext> thTagOpen() { 7982 return getRuleContexts(ThTagOpenContext.class); 7983 } 7984 public ThTagOpenContext thTagOpen(int i) { 7985 return getRuleContext(ThTagOpenContext.class,i); 7986 } 7987 public List<BodyTagOpenContext> bodyTagOpen() { 7988 return getRuleContexts(BodyTagOpenContext.class); 7989 } 7990 public BodyTagOpenContext bodyTagOpen(int i) { 7991 return getRuleContext(BodyTagOpenContext.class,i); 7992 } 7993 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7994 return getRuleContexts(ColgroupTagOpenContext.class); 7995 } 7996 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7997 return getRuleContext(ColgroupTagOpenContext.class,i); 7998 } 7999 public List<DdTagOpenContext> ddTagOpen() { 8000 return getRuleContexts(DdTagOpenContext.class); 8001 } 8002 public DdTagOpenContext ddTagOpen(int i) { 8003 return getRuleContext(DdTagOpenContext.class,i); 8004 } 8005 public List<DtTagOpenContext> dtTagOpen() { 8006 return getRuleContexts(DtTagOpenContext.class); 8007 } 8008 public DtTagOpenContext dtTagOpen(int i) { 8009 return getRuleContext(DtTagOpenContext.class,i); 8010 } 8011 public List<HtmlTagOpenContext> htmlTagOpen() { 8012 return getRuleContexts(HtmlTagOpenContext.class); 8013 } 8014 public HtmlTagOpenContext htmlTagOpen(int i) { 8015 return getRuleContext(HtmlTagOpenContext.class,i); 8016 } 8017 public List<OptionTagOpenContext> optionTagOpen() { 8018 return getRuleContexts(OptionTagOpenContext.class); 8019 } 8020 public OptionTagOpenContext optionTagOpen(int i) { 8021 return getRuleContext(OptionTagOpenContext.class,i); 8022 } 8023 public List<TbodyTagOpenContext> tbodyTagOpen() { 8024 return getRuleContexts(TbodyTagOpenContext.class); 8025 } 8026 public TbodyTagOpenContext tbodyTagOpen(int i) { 8027 return getRuleContext(TbodyTagOpenContext.class,i); 8028 } 8029 public List<TheadTagOpenContext> theadTagOpen() { 8030 return getRuleContexts(TheadTagOpenContext.class); 8031 } 8032 public TheadTagOpenContext theadTagOpen(int i) { 8033 return getRuleContext(TheadTagOpenContext.class,i); 8034 } 8035 public List<TfootTagOpenContext> tfootTagOpen() { 8036 return getRuleContexts(TfootTagOpenContext.class); 8037 } 8038 public TfootTagOpenContext tfootTagOpen(int i) { 8039 return getRuleContext(TfootTagOpenContext.class,i); 8040 } 8041 public List<HtmlCommentContext> htmlComment() { 8042 return getRuleContexts(HtmlCommentContext.class); 8043 } 8044 public HtmlCommentContext htmlComment(int i) { 8045 return getRuleContext(HtmlCommentContext.class,i); 8046 } 8047 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8048 public TerminalNode CDATA(int i) { 8049 return getToken(JavadocParser.CDATA, i); 8050 } 8051 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8052 public TerminalNode NEWLINE(int i) { 8053 return getToken(JavadocParser.NEWLINE, i); 8054 } 8055 public List<TextContext> text() { 8056 return getRuleContexts(TextContext.class); 8057 } 8058 public TextContext text(int i) { 8059 return getRuleContext(TextContext.class,i); 8060 } 8061 public List<JavadocInlineTagContext> javadocInlineTag() { 8062 return getRuleContexts(JavadocInlineTagContext.class); 8063 } 8064 public JavadocInlineTagContext javadocInlineTag(int i) { 8065 return getRuleContext(JavadocInlineTagContext.class,i); 8066 } 8067 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8068 public TerminalNode LEADING_ASTERISK(int i) { 8069 return getToken(JavadocParser.LEADING_ASTERISK, i); 8070 } 8071 public HeadContext(ParserRuleContext parent, int invokingState) { 8072 super(parent, invokingState); 8073 } 8074 @Override public int getRuleIndex() { return RULE_head; } 8075 @Override 8076 public void enterRule(ParseTreeListener listener) { 8077 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 8078 } 8079 @Override 8080 public void exitRule(ParseTreeListener listener) { 8081 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8082 } 8083 @Override 8084 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8085 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8086 else return visitor.visitChildren(this); 8087 } 8088 } 8089 8090 public final HeadContext head() throws RecognitionException { 8091 HeadContext _localctx = new HeadContext(_ctx, getState()); 8092 enterRule(_localctx, 70, RULE_head); 8093 try { 8094 int _alt; 8095 enterOuterAlt(_localctx, 1); 8096 { 8097 setState(951); 8098 headTagOpen(); 8099 setState(991); 8100 _errHandler.sync(this); 8101 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8102 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8103 if ( _alt==1 ) { 8104 { 8105 setState(989); 8106 _errHandler.sync(this); 8107 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8108 case 1: 8109 { 8110 setState(952); 8111 htmlTag(); 8112 } 8113 break; 8114 case 2: 8115 { 8116 setState(953); 8117 singletonTag(); 8118 } 8119 break; 8120 case 3: 8121 { 8122 setState(954); 8123 paragraph(); 8124 } 8125 break; 8126 case 4: 8127 { 8128 setState(955); 8129 li(); 8130 } 8131 break; 8132 case 5: 8133 { 8134 setState(956); 8135 tr(); 8136 } 8137 break; 8138 case 6: 8139 { 8140 setState(957); 8141 td(); 8142 } 8143 break; 8144 case 7: 8145 { 8146 setState(958); 8147 th(); 8148 } 8149 break; 8150 case 8: 8151 { 8152 setState(959); 8153 body(); 8154 } 8155 break; 8156 case 9: 8157 { 8158 setState(960); 8159 colgroup(); 8160 } 8161 break; 8162 case 10: 8163 { 8164 setState(961); 8165 dd(); 8166 } 8167 break; 8168 case 11: 8169 { 8170 setState(962); 8171 dt(); 8172 } 8173 break; 8174 case 12: 8175 { 8176 setState(963); 8177 html(); 8178 } 8179 break; 8180 case 13: 8181 { 8182 setState(964); 8183 option(); 8184 } 8185 break; 8186 case 14: 8187 { 8188 setState(965); 8189 tbody(); 8190 } 8191 break; 8192 case 15: 8193 { 8194 setState(966); 8195 thead(); 8196 } 8197 break; 8198 case 16: 8199 { 8200 setState(967); 8201 tfoot(); 8202 } 8203 break; 8204 case 17: 8205 { 8206 setState(968); 8207 pTagOpen(); 8208 } 8209 break; 8210 case 18: 8211 { 8212 setState(969); 8213 liTagOpen(); 8214 } 8215 break; 8216 case 19: 8217 { 8218 setState(970); 8219 trTagOpen(); 8220 } 8221 break; 8222 case 20: 8223 { 8224 setState(971); 8225 tdTagOpen(); 8226 } 8227 break; 8228 case 21: 8229 { 8230 setState(972); 8231 thTagOpen(); 8232 } 8233 break; 8234 case 22: 8235 { 8236 setState(973); 8237 bodyTagOpen(); 8238 } 8239 break; 8240 case 23: 8241 { 8242 setState(974); 8243 colgroupTagOpen(); 8244 } 8245 break; 8246 case 24: 8247 { 8248 setState(975); 8249 ddTagOpen(); 8250 } 8251 break; 8252 case 25: 8253 { 8254 setState(976); 8255 dtTagOpen(); 8256 } 8257 break; 8258 case 26: 8259 { 8260 setState(977); 8261 htmlTagOpen(); 8262 } 8263 break; 8264 case 27: 8265 { 8266 setState(978); 8267 optionTagOpen(); 8268 } 8269 break; 8270 case 28: 8271 { 8272 setState(979); 8273 tbodyTagOpen(); 8274 } 8275 break; 8276 case 29: 8277 { 8278 setState(980); 8279 theadTagOpen(); 8280 } 8281 break; 8282 case 30: 8283 { 8284 setState(981); 8285 tfootTagOpen(); 8286 } 8287 break; 8288 case 31: 8289 { 8290 { 8291 setState(982); 8292 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8293 setState(983); 8294 match(LEADING_ASTERISK); 8295 } 8296 } 8297 break; 8298 case 32: 8299 { 8300 setState(984); 8301 htmlComment(); 8302 } 8303 break; 8304 case 33: 8305 { 8306 setState(985); 8307 match(CDATA); 8308 } 8309 break; 8310 case 34: 8311 { 8312 setState(986); 8313 match(NEWLINE); 8314 } 8315 break; 8316 case 35: 8317 { 8318 setState(987); 8319 text(); 8320 } 8321 break; 8322 case 36: 8323 { 8324 setState(988); 8325 javadocInlineTag(); 8326 } 8327 break; 8328 } 8329 } 8330 } 8331 setState(993); 8332 _errHandler.sync(this); 8333 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8334 } 8335 setState(994); 8336 headTagClose(); 8337 } 8338 } 8339 catch (RecognitionException re) { 8340 _localctx.exception = re; 8341 _errHandler.reportError(this, re); 8342 _errHandler.recover(this, re); 8343 } 8344 finally { 8345 exitRule(); 8346 } 8347 return _localctx; 8348 } 8349 8350 public static class HtmlTagOpenContext extends ParserRuleContext { 8351 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8352 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8353 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8354 public List<AttributeContext> attribute() { 8355 return getRuleContexts(AttributeContext.class); 8356 } 8357 public AttributeContext attribute(int i) { 8358 return getRuleContext(AttributeContext.class,i); 8359 } 8360 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8361 public TerminalNode NEWLINE(int i) { 8362 return getToken(JavadocParser.NEWLINE, i); 8363 } 8364 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8365 public TerminalNode LEADING_ASTERISK(int i) { 8366 return getToken(JavadocParser.LEADING_ASTERISK, i); 8367 } 8368 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8369 public TerminalNode WS(int i) { 8370 return getToken(JavadocParser.WS, i); 8371 } 8372 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8373 super(parent, invokingState); 8374 } 8375 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8376 @Override 8377 public void enterRule(ParseTreeListener listener) { 8378 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8379 } 8380 @Override 8381 public void exitRule(ParseTreeListener listener) { 8382 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8383 } 8384 @Override 8385 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8386 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8387 else return visitor.visitChildren(this); 8388 } 8389 } 8390 8391 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8392 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8393 enterRule(_localctx, 72, RULE_htmlTagOpen); 8394 int _la; 8395 try { 8396 enterOuterAlt(_localctx, 1); 8397 { 8398 setState(996); 8399 match(OPEN); 8400 setState(997); 8401 match(HTML_HTML_TAG_NAME); 8402 setState(1004); 8403 _errHandler.sync(this); 8404 _la = _input.LA(1); 8405 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8406 { 8407 setState(1002); 8408 _errHandler.sync(this); 8409 switch (_input.LA(1)) { 8410 case HTML_TAG_NAME: 8411 { 8412 setState(998); 8413 attribute(); 8414 } 8415 break; 8416 case NEWLINE: 8417 { 8418 setState(999); 8419 match(NEWLINE); 8420 } 8421 break; 8422 case LEADING_ASTERISK: 8423 { 8424 setState(1000); 8425 match(LEADING_ASTERISK); 8426 } 8427 break; 8428 case WS: 8429 { 8430 setState(1001); 8431 match(WS); 8432 } 8433 break; 8434 default: 8435 throw new NoViableAltException(this); 8436 } 8437 } 8438 setState(1006); 8439 _errHandler.sync(this); 8440 _la = _input.LA(1); 8441 } 8442 setState(1007); 8443 match(CLOSE); 8444 } 8445 } 8446 catch (RecognitionException re) { 8447 _localctx.exception = re; 8448 _errHandler.reportError(this, re); 8449 _errHandler.recover(this, re); 8450 } 8451 finally { 8452 exitRule(); 8453 } 8454 return _localctx; 8455 } 8456 8457 public static class HtmlTagCloseContext extends ParserRuleContext { 8458 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8459 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8460 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8461 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8462 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8463 public TerminalNode NEWLINE(int i) { 8464 return getToken(JavadocParser.NEWLINE, i); 8465 } 8466 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8467 public TerminalNode LEADING_ASTERISK(int i) { 8468 return getToken(JavadocParser.LEADING_ASTERISK, i); 8469 } 8470 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8471 public TerminalNode WS(int i) { 8472 return getToken(JavadocParser.WS, i); 8473 } 8474 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8475 super(parent, invokingState); 8476 } 8477 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8478 @Override 8479 public void enterRule(ParseTreeListener listener) { 8480 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8481 } 8482 @Override 8483 public void exitRule(ParseTreeListener listener) { 8484 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8485 } 8486 @Override 8487 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8488 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8489 else return visitor.visitChildren(this); 8490 } 8491 } 8492 8493 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8494 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8495 enterRule(_localctx, 74, RULE_htmlTagClose); 8496 int _la; 8497 try { 8498 enterOuterAlt(_localctx, 1); 8499 { 8500 setState(1009); 8501 match(OPEN); 8502 setState(1010); 8503 match(SLASH); 8504 setState(1011); 8505 match(HTML_HTML_TAG_NAME); 8506 setState(1015); 8507 _errHandler.sync(this); 8508 _la = _input.LA(1); 8509 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8510 { 8511 { 8512 setState(1012); 8513 _la = _input.LA(1); 8514 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8515 _errHandler.recoverInline(this); 8516 } 8517 else { 8518 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8519 _errHandler.reportMatch(this); 8520 consume(); 8521 } 8522 } 8523 } 8524 setState(1017); 8525 _errHandler.sync(this); 8526 _la = _input.LA(1); 8527 } 8528 setState(1018); 8529 match(CLOSE); 8530 } 8531 } 8532 catch (RecognitionException re) { 8533 _localctx.exception = re; 8534 _errHandler.reportError(this, re); 8535 _errHandler.recover(this, re); 8536 } 8537 finally { 8538 exitRule(); 8539 } 8540 return _localctx; 8541 } 8542 8543 public static class HtmlContext extends ParserRuleContext { 8544 public HtmlTagOpenContext htmlTagOpen() { 8545 return getRuleContext(HtmlTagOpenContext.class,0); 8546 } 8547 public HtmlTagCloseContext htmlTagClose() { 8548 return getRuleContext(HtmlTagCloseContext.class,0); 8549 } 8550 public List<HtmlTagContext> htmlTag() { 8551 return getRuleContexts(HtmlTagContext.class); 8552 } 8553 public HtmlTagContext htmlTag(int i) { 8554 return getRuleContext(HtmlTagContext.class,i); 8555 } 8556 public List<SingletonTagContext> singletonTag() { 8557 return getRuleContexts(SingletonTagContext.class); 8558 } 8559 public SingletonTagContext singletonTag(int i) { 8560 return getRuleContext(SingletonTagContext.class,i); 8561 } 8562 public List<ParagraphContext> paragraph() { 8563 return getRuleContexts(ParagraphContext.class); 8564 } 8565 public ParagraphContext paragraph(int i) { 8566 return getRuleContext(ParagraphContext.class,i); 8567 } 8568 public List<LiContext> li() { 8569 return getRuleContexts(LiContext.class); 8570 } 8571 public LiContext li(int i) { 8572 return getRuleContext(LiContext.class,i); 8573 } 8574 public List<TrContext> tr() { 8575 return getRuleContexts(TrContext.class); 8576 } 8577 public TrContext tr(int i) { 8578 return getRuleContext(TrContext.class,i); 8579 } 8580 public List<TdContext> td() { 8581 return getRuleContexts(TdContext.class); 8582 } 8583 public TdContext td(int i) { 8584 return getRuleContext(TdContext.class,i); 8585 } 8586 public List<ThContext> th() { 8587 return getRuleContexts(ThContext.class); 8588 } 8589 public ThContext th(int i) { 8590 return getRuleContext(ThContext.class,i); 8591 } 8592 public List<BodyContext> body() { 8593 return getRuleContexts(BodyContext.class); 8594 } 8595 public BodyContext body(int i) { 8596 return getRuleContext(BodyContext.class,i); 8597 } 8598 public List<ColgroupContext> colgroup() { 8599 return getRuleContexts(ColgroupContext.class); 8600 } 8601 public ColgroupContext colgroup(int i) { 8602 return getRuleContext(ColgroupContext.class,i); 8603 } 8604 public List<DdContext> dd() { 8605 return getRuleContexts(DdContext.class); 8606 } 8607 public DdContext dd(int i) { 8608 return getRuleContext(DdContext.class,i); 8609 } 8610 public List<DtContext> dt() { 8611 return getRuleContexts(DtContext.class); 8612 } 8613 public DtContext dt(int i) { 8614 return getRuleContext(DtContext.class,i); 8615 } 8616 public List<HeadContext> head() { 8617 return getRuleContexts(HeadContext.class); 8618 } 8619 public HeadContext head(int i) { 8620 return getRuleContext(HeadContext.class,i); 8621 } 8622 public List<OptionContext> option() { 8623 return getRuleContexts(OptionContext.class); 8624 } 8625 public OptionContext option(int i) { 8626 return getRuleContext(OptionContext.class,i); 8627 } 8628 public List<TbodyContext> tbody() { 8629 return getRuleContexts(TbodyContext.class); 8630 } 8631 public TbodyContext tbody(int i) { 8632 return getRuleContext(TbodyContext.class,i); 8633 } 8634 public List<TheadContext> thead() { 8635 return getRuleContexts(TheadContext.class); 8636 } 8637 public TheadContext thead(int i) { 8638 return getRuleContext(TheadContext.class,i); 8639 } 8640 public List<TfootContext> tfoot() { 8641 return getRuleContexts(TfootContext.class); 8642 } 8643 public TfootContext tfoot(int i) { 8644 return getRuleContext(TfootContext.class,i); 8645 } 8646 public List<PTagOpenContext> pTagOpen() { 8647 return getRuleContexts(PTagOpenContext.class); 8648 } 8649 public PTagOpenContext pTagOpen(int i) { 8650 return getRuleContext(PTagOpenContext.class,i); 8651 } 8652 public List<LiTagOpenContext> liTagOpen() { 8653 return getRuleContexts(LiTagOpenContext.class); 8654 } 8655 public LiTagOpenContext liTagOpen(int i) { 8656 return getRuleContext(LiTagOpenContext.class,i); 8657 } 8658 public List<TrTagOpenContext> trTagOpen() { 8659 return getRuleContexts(TrTagOpenContext.class); 8660 } 8661 public TrTagOpenContext trTagOpen(int i) { 8662 return getRuleContext(TrTagOpenContext.class,i); 8663 } 8664 public List<TdTagOpenContext> tdTagOpen() { 8665 return getRuleContexts(TdTagOpenContext.class); 8666 } 8667 public TdTagOpenContext tdTagOpen(int i) { 8668 return getRuleContext(TdTagOpenContext.class,i); 8669 } 8670 public List<ThTagOpenContext> thTagOpen() { 8671 return getRuleContexts(ThTagOpenContext.class); 8672 } 8673 public ThTagOpenContext thTagOpen(int i) { 8674 return getRuleContext(ThTagOpenContext.class,i); 8675 } 8676 public List<BodyTagOpenContext> bodyTagOpen() { 8677 return getRuleContexts(BodyTagOpenContext.class); 8678 } 8679 public BodyTagOpenContext bodyTagOpen(int i) { 8680 return getRuleContext(BodyTagOpenContext.class,i); 8681 } 8682 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8683 return getRuleContexts(ColgroupTagOpenContext.class); 8684 } 8685 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8686 return getRuleContext(ColgroupTagOpenContext.class,i); 8687 } 8688 public List<DdTagOpenContext> ddTagOpen() { 8689 return getRuleContexts(DdTagOpenContext.class); 8690 } 8691 public DdTagOpenContext ddTagOpen(int i) { 8692 return getRuleContext(DdTagOpenContext.class,i); 8693 } 8694 public List<DtTagOpenContext> dtTagOpen() { 8695 return getRuleContexts(DtTagOpenContext.class); 8696 } 8697 public DtTagOpenContext dtTagOpen(int i) { 8698 return getRuleContext(DtTagOpenContext.class,i); 8699 } 8700 public List<HeadTagOpenContext> headTagOpen() { 8701 return getRuleContexts(HeadTagOpenContext.class); 8702 } 8703 public HeadTagOpenContext headTagOpen(int i) { 8704 return getRuleContext(HeadTagOpenContext.class,i); 8705 } 8706 public List<OptionTagOpenContext> optionTagOpen() { 8707 return getRuleContexts(OptionTagOpenContext.class); 8708 } 8709 public OptionTagOpenContext optionTagOpen(int i) { 8710 return getRuleContext(OptionTagOpenContext.class,i); 8711 } 8712 public List<TbodyTagOpenContext> tbodyTagOpen() { 8713 return getRuleContexts(TbodyTagOpenContext.class); 8714 } 8715 public TbodyTagOpenContext tbodyTagOpen(int i) { 8716 return getRuleContext(TbodyTagOpenContext.class,i); 8717 } 8718 public List<TheadTagOpenContext> theadTagOpen() { 8719 return getRuleContexts(TheadTagOpenContext.class); 8720 } 8721 public TheadTagOpenContext theadTagOpen(int i) { 8722 return getRuleContext(TheadTagOpenContext.class,i); 8723 } 8724 public List<TfootTagOpenContext> tfootTagOpen() { 8725 return getRuleContexts(TfootTagOpenContext.class); 8726 } 8727 public TfootTagOpenContext tfootTagOpen(int i) { 8728 return getRuleContext(TfootTagOpenContext.class,i); 8729 } 8730 public List<HtmlCommentContext> htmlComment() { 8731 return getRuleContexts(HtmlCommentContext.class); 8732 } 8733 public HtmlCommentContext htmlComment(int i) { 8734 return getRuleContext(HtmlCommentContext.class,i); 8735 } 8736 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8737 public TerminalNode CDATA(int i) { 8738 return getToken(JavadocParser.CDATA, i); 8739 } 8740 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8741 public TerminalNode NEWLINE(int i) { 8742 return getToken(JavadocParser.NEWLINE, i); 8743 } 8744 public List<TextContext> text() { 8745 return getRuleContexts(TextContext.class); 8746 } 8747 public TextContext text(int i) { 8748 return getRuleContext(TextContext.class,i); 8749 } 8750 public List<JavadocInlineTagContext> javadocInlineTag() { 8751 return getRuleContexts(JavadocInlineTagContext.class); 8752 } 8753 public JavadocInlineTagContext javadocInlineTag(int i) { 8754 return getRuleContext(JavadocInlineTagContext.class,i); 8755 } 8756 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8757 public TerminalNode LEADING_ASTERISK(int i) { 8758 return getToken(JavadocParser.LEADING_ASTERISK, i); 8759 } 8760 public HtmlContext(ParserRuleContext parent, int invokingState) { 8761 super(parent, invokingState); 8762 } 8763 @Override public int getRuleIndex() { return RULE_html; } 8764 @Override 8765 public void enterRule(ParseTreeListener listener) { 8766 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8767 } 8768 @Override 8769 public void exitRule(ParseTreeListener listener) { 8770 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8771 } 8772 @Override 8773 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8774 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8775 else return visitor.visitChildren(this); 8776 } 8777 } 8778 8779 public final HtmlContext html() throws RecognitionException { 8780 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8781 enterRule(_localctx, 76, RULE_html); 8782 try { 8783 int _alt; 8784 enterOuterAlt(_localctx, 1); 8785 { 8786 setState(1020); 8787 htmlTagOpen(); 8788 setState(1060); 8789 _errHandler.sync(this); 8790 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8791 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8792 if ( _alt==1 ) { 8793 { 8794 setState(1058); 8795 _errHandler.sync(this); 8796 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8797 case 1: 8798 { 8799 setState(1021); 8800 htmlTag(); 8801 } 8802 break; 8803 case 2: 8804 { 8805 setState(1022); 8806 singletonTag(); 8807 } 8808 break; 8809 case 3: 8810 { 8811 setState(1023); 8812 paragraph(); 8813 } 8814 break; 8815 case 4: 8816 { 8817 setState(1024); 8818 li(); 8819 } 8820 break; 8821 case 5: 8822 { 8823 setState(1025); 8824 tr(); 8825 } 8826 break; 8827 case 6: 8828 { 8829 setState(1026); 8830 td(); 8831 } 8832 break; 8833 case 7: 8834 { 8835 setState(1027); 8836 th(); 8837 } 8838 break; 8839 case 8: 8840 { 8841 setState(1028); 8842 body(); 8843 } 8844 break; 8845 case 9: 8846 { 8847 setState(1029); 8848 colgroup(); 8849 } 8850 break; 8851 case 10: 8852 { 8853 setState(1030); 8854 dd(); 8855 } 8856 break; 8857 case 11: 8858 { 8859 setState(1031); 8860 dt(); 8861 } 8862 break; 8863 case 12: 8864 { 8865 setState(1032); 8866 head(); 8867 } 8868 break; 8869 case 13: 8870 { 8871 setState(1033); 8872 option(); 8873 } 8874 break; 8875 case 14: 8876 { 8877 setState(1034); 8878 tbody(); 8879 } 8880 break; 8881 case 15: 8882 { 8883 setState(1035); 8884 thead(); 8885 } 8886 break; 8887 case 16: 8888 { 8889 setState(1036); 8890 tfoot(); 8891 } 8892 break; 8893 case 17: 8894 { 8895 setState(1037); 8896 pTagOpen(); 8897 } 8898 break; 8899 case 18: 8900 { 8901 setState(1038); 8902 liTagOpen(); 8903 } 8904 break; 8905 case 19: 8906 { 8907 setState(1039); 8908 trTagOpen(); 8909 } 8910 break; 8911 case 20: 8912 { 8913 setState(1040); 8914 tdTagOpen(); 8915 } 8916 break; 8917 case 21: 8918 { 8919 setState(1041); 8920 thTagOpen(); 8921 } 8922 break; 8923 case 22: 8924 { 8925 setState(1042); 8926 bodyTagOpen(); 8927 } 8928 break; 8929 case 23: 8930 { 8931 setState(1043); 8932 colgroupTagOpen(); 8933 } 8934 break; 8935 case 24: 8936 { 8937 setState(1044); 8938 ddTagOpen(); 8939 } 8940 break; 8941 case 25: 8942 { 8943 setState(1045); 8944 dtTagOpen(); 8945 } 8946 break; 8947 case 26: 8948 { 8949 setState(1046); 8950 headTagOpen(); 8951 } 8952 break; 8953 case 27: 8954 { 8955 setState(1047); 8956 optionTagOpen(); 8957 } 8958 break; 8959 case 28: 8960 { 8961 setState(1048); 8962 tbodyTagOpen(); 8963 } 8964 break; 8965 case 29: 8966 { 8967 setState(1049); 8968 theadTagOpen(); 8969 } 8970 break; 8971 case 30: 8972 { 8973 setState(1050); 8974 tfootTagOpen(); 8975 } 8976 break; 8977 case 31: 8978 { 8979 { 8980 setState(1051); 8981 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8982 setState(1052); 8983 match(LEADING_ASTERISK); 8984 } 8985 } 8986 break; 8987 case 32: 8988 { 8989 setState(1053); 8990 htmlComment(); 8991 } 8992 break; 8993 case 33: 8994 { 8995 setState(1054); 8996 match(CDATA); 8997 } 8998 break; 8999 case 34: 9000 { 9001 setState(1055); 9002 match(NEWLINE); 9003 } 9004 break; 9005 case 35: 9006 { 9007 setState(1056); 9008 text(); 9009 } 9010 break; 9011 case 36: 9012 { 9013 setState(1057); 9014 javadocInlineTag(); 9015 } 9016 break; 9017 } 9018 } 9019 } 9020 setState(1062); 9021 _errHandler.sync(this); 9022 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 9023 } 9024 setState(1063); 9025 htmlTagClose(); 9026 } 9027 } 9028 catch (RecognitionException re) { 9029 _localctx.exception = re; 9030 _errHandler.reportError(this, re); 9031 _errHandler.recover(this, re); 9032 } 9033 finally { 9034 exitRule(); 9035 } 9036 return _localctx; 9037 } 9038 9039 public static class OptionTagOpenContext extends ParserRuleContext { 9040 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9041 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9042 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9043 public List<AttributeContext> attribute() { 9044 return getRuleContexts(AttributeContext.class); 9045 } 9046 public AttributeContext attribute(int i) { 9047 return getRuleContext(AttributeContext.class,i); 9048 } 9049 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9050 public TerminalNode NEWLINE(int i) { 9051 return getToken(JavadocParser.NEWLINE, i); 9052 } 9053 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9054 public TerminalNode LEADING_ASTERISK(int i) { 9055 return getToken(JavadocParser.LEADING_ASTERISK, i); 9056 } 9057 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9058 public TerminalNode WS(int i) { 9059 return getToken(JavadocParser.WS, i); 9060 } 9061 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 9062 super(parent, invokingState); 9063 } 9064 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 9065 @Override 9066 public void enterRule(ParseTreeListener listener) { 9067 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 9068 } 9069 @Override 9070 public void exitRule(ParseTreeListener listener) { 9071 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 9072 } 9073 @Override 9074 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9075 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 9076 else return visitor.visitChildren(this); 9077 } 9078 } 9079 9080 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 9081 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 9082 enterRule(_localctx, 78, RULE_optionTagOpen); 9083 int _la; 9084 try { 9085 enterOuterAlt(_localctx, 1); 9086 { 9087 setState(1065); 9088 match(OPEN); 9089 setState(1066); 9090 match(OPTION_HTML_TAG_NAME); 9091 setState(1073); 9092 _errHandler.sync(this); 9093 _la = _input.LA(1); 9094 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9095 { 9096 setState(1071); 9097 _errHandler.sync(this); 9098 switch (_input.LA(1)) { 9099 case HTML_TAG_NAME: 9100 { 9101 setState(1067); 9102 attribute(); 9103 } 9104 break; 9105 case NEWLINE: 9106 { 9107 setState(1068); 9108 match(NEWLINE); 9109 } 9110 break; 9111 case LEADING_ASTERISK: 9112 { 9113 setState(1069); 9114 match(LEADING_ASTERISK); 9115 } 9116 break; 9117 case WS: 9118 { 9119 setState(1070); 9120 match(WS); 9121 } 9122 break; 9123 default: 9124 throw new NoViableAltException(this); 9125 } 9126 } 9127 setState(1075); 9128 _errHandler.sync(this); 9129 _la = _input.LA(1); 9130 } 9131 setState(1076); 9132 match(CLOSE); 9133 } 9134 } 9135 catch (RecognitionException re) { 9136 _localctx.exception = re; 9137 _errHandler.reportError(this, re); 9138 _errHandler.recover(this, re); 9139 } 9140 finally { 9141 exitRule(); 9142 } 9143 return _localctx; 9144 } 9145 9146 public static class OptionTagCloseContext extends ParserRuleContext { 9147 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9148 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9149 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9150 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9151 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9152 public TerminalNode NEWLINE(int i) { 9153 return getToken(JavadocParser.NEWLINE, i); 9154 } 9155 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9156 public TerminalNode LEADING_ASTERISK(int i) { 9157 return getToken(JavadocParser.LEADING_ASTERISK, i); 9158 } 9159 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9160 public TerminalNode WS(int i) { 9161 return getToken(JavadocParser.WS, i); 9162 } 9163 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9164 super(parent, invokingState); 9165 } 9166 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9167 @Override 9168 public void enterRule(ParseTreeListener listener) { 9169 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9170 } 9171 @Override 9172 public void exitRule(ParseTreeListener listener) { 9173 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9174 } 9175 @Override 9176 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9177 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9178 else return visitor.visitChildren(this); 9179 } 9180 } 9181 9182 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9183 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9184 enterRule(_localctx, 80, RULE_optionTagClose); 9185 int _la; 9186 try { 9187 enterOuterAlt(_localctx, 1); 9188 { 9189 setState(1078); 9190 match(OPEN); 9191 setState(1079); 9192 match(SLASH); 9193 setState(1080); 9194 match(OPTION_HTML_TAG_NAME); 9195 setState(1084); 9196 _errHandler.sync(this); 9197 _la = _input.LA(1); 9198 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9199 { 9200 { 9201 setState(1081); 9202 _la = _input.LA(1); 9203 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9204 _errHandler.recoverInline(this); 9205 } 9206 else { 9207 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9208 _errHandler.reportMatch(this); 9209 consume(); 9210 } 9211 } 9212 } 9213 setState(1086); 9214 _errHandler.sync(this); 9215 _la = _input.LA(1); 9216 } 9217 setState(1087); 9218 match(CLOSE); 9219 } 9220 } 9221 catch (RecognitionException re) { 9222 _localctx.exception = re; 9223 _errHandler.reportError(this, re); 9224 _errHandler.recover(this, re); 9225 } 9226 finally { 9227 exitRule(); 9228 } 9229 return _localctx; 9230 } 9231 9232 public static class OptionContext extends ParserRuleContext { 9233 public OptionTagOpenContext optionTagOpen() { 9234 return getRuleContext(OptionTagOpenContext.class,0); 9235 } 9236 public OptionTagCloseContext optionTagClose() { 9237 return getRuleContext(OptionTagCloseContext.class,0); 9238 } 9239 public List<HtmlTagContext> htmlTag() { 9240 return getRuleContexts(HtmlTagContext.class); 9241 } 9242 public HtmlTagContext htmlTag(int i) { 9243 return getRuleContext(HtmlTagContext.class,i); 9244 } 9245 public List<SingletonTagContext> singletonTag() { 9246 return getRuleContexts(SingletonTagContext.class); 9247 } 9248 public SingletonTagContext singletonTag(int i) { 9249 return getRuleContext(SingletonTagContext.class,i); 9250 } 9251 public List<ParagraphContext> paragraph() { 9252 return getRuleContexts(ParagraphContext.class); 9253 } 9254 public ParagraphContext paragraph(int i) { 9255 return getRuleContext(ParagraphContext.class,i); 9256 } 9257 public List<LiContext> li() { 9258 return getRuleContexts(LiContext.class); 9259 } 9260 public LiContext li(int i) { 9261 return getRuleContext(LiContext.class,i); 9262 } 9263 public List<TrContext> tr() { 9264 return getRuleContexts(TrContext.class); 9265 } 9266 public TrContext tr(int i) { 9267 return getRuleContext(TrContext.class,i); 9268 } 9269 public List<TdContext> td() { 9270 return getRuleContexts(TdContext.class); 9271 } 9272 public TdContext td(int i) { 9273 return getRuleContext(TdContext.class,i); 9274 } 9275 public List<ThContext> th() { 9276 return getRuleContexts(ThContext.class); 9277 } 9278 public ThContext th(int i) { 9279 return getRuleContext(ThContext.class,i); 9280 } 9281 public List<BodyContext> body() { 9282 return getRuleContexts(BodyContext.class); 9283 } 9284 public BodyContext body(int i) { 9285 return getRuleContext(BodyContext.class,i); 9286 } 9287 public List<ColgroupContext> colgroup() { 9288 return getRuleContexts(ColgroupContext.class); 9289 } 9290 public ColgroupContext colgroup(int i) { 9291 return getRuleContext(ColgroupContext.class,i); 9292 } 9293 public List<DdContext> dd() { 9294 return getRuleContexts(DdContext.class); 9295 } 9296 public DdContext dd(int i) { 9297 return getRuleContext(DdContext.class,i); 9298 } 9299 public List<DtContext> dt() { 9300 return getRuleContexts(DtContext.class); 9301 } 9302 public DtContext dt(int i) { 9303 return getRuleContext(DtContext.class,i); 9304 } 9305 public List<HeadContext> head() { 9306 return getRuleContexts(HeadContext.class); 9307 } 9308 public HeadContext head(int i) { 9309 return getRuleContext(HeadContext.class,i); 9310 } 9311 public List<HtmlContext> html() { 9312 return getRuleContexts(HtmlContext.class); 9313 } 9314 public HtmlContext html(int i) { 9315 return getRuleContext(HtmlContext.class,i); 9316 } 9317 public List<TbodyContext> tbody() { 9318 return getRuleContexts(TbodyContext.class); 9319 } 9320 public TbodyContext tbody(int i) { 9321 return getRuleContext(TbodyContext.class,i); 9322 } 9323 public List<TheadContext> thead() { 9324 return getRuleContexts(TheadContext.class); 9325 } 9326 public TheadContext thead(int i) { 9327 return getRuleContext(TheadContext.class,i); 9328 } 9329 public List<TfootContext> tfoot() { 9330 return getRuleContexts(TfootContext.class); 9331 } 9332 public TfootContext tfoot(int i) { 9333 return getRuleContext(TfootContext.class,i); 9334 } 9335 public List<PTagOpenContext> pTagOpen() { 9336 return getRuleContexts(PTagOpenContext.class); 9337 } 9338 public PTagOpenContext pTagOpen(int i) { 9339 return getRuleContext(PTagOpenContext.class,i); 9340 } 9341 public List<LiTagOpenContext> liTagOpen() { 9342 return getRuleContexts(LiTagOpenContext.class); 9343 } 9344 public LiTagOpenContext liTagOpen(int i) { 9345 return getRuleContext(LiTagOpenContext.class,i); 9346 } 9347 public List<TrTagOpenContext> trTagOpen() { 9348 return getRuleContexts(TrTagOpenContext.class); 9349 } 9350 public TrTagOpenContext trTagOpen(int i) { 9351 return getRuleContext(TrTagOpenContext.class,i); 9352 } 9353 public List<TdTagOpenContext> tdTagOpen() { 9354 return getRuleContexts(TdTagOpenContext.class); 9355 } 9356 public TdTagOpenContext tdTagOpen(int i) { 9357 return getRuleContext(TdTagOpenContext.class,i); 9358 } 9359 public List<ThTagOpenContext> thTagOpen() { 9360 return getRuleContexts(ThTagOpenContext.class); 9361 } 9362 public ThTagOpenContext thTagOpen(int i) { 9363 return getRuleContext(ThTagOpenContext.class,i); 9364 } 9365 public List<BodyTagOpenContext> bodyTagOpen() { 9366 return getRuleContexts(BodyTagOpenContext.class); 9367 } 9368 public BodyTagOpenContext bodyTagOpen(int i) { 9369 return getRuleContext(BodyTagOpenContext.class,i); 9370 } 9371 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9372 return getRuleContexts(ColgroupTagOpenContext.class); 9373 } 9374 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9375 return getRuleContext(ColgroupTagOpenContext.class,i); 9376 } 9377 public List<DdTagOpenContext> ddTagOpen() { 9378 return getRuleContexts(DdTagOpenContext.class); 9379 } 9380 public DdTagOpenContext ddTagOpen(int i) { 9381 return getRuleContext(DdTagOpenContext.class,i); 9382 } 9383 public List<DtTagOpenContext> dtTagOpen() { 9384 return getRuleContexts(DtTagOpenContext.class); 9385 } 9386 public DtTagOpenContext dtTagOpen(int i) { 9387 return getRuleContext(DtTagOpenContext.class,i); 9388 } 9389 public List<HeadTagOpenContext> headTagOpen() { 9390 return getRuleContexts(HeadTagOpenContext.class); 9391 } 9392 public HeadTagOpenContext headTagOpen(int i) { 9393 return getRuleContext(HeadTagOpenContext.class,i); 9394 } 9395 public List<HtmlTagOpenContext> htmlTagOpen() { 9396 return getRuleContexts(HtmlTagOpenContext.class); 9397 } 9398 public HtmlTagOpenContext htmlTagOpen(int i) { 9399 return getRuleContext(HtmlTagOpenContext.class,i); 9400 } 9401 public List<TbodyTagOpenContext> tbodyTagOpen() { 9402 return getRuleContexts(TbodyTagOpenContext.class); 9403 } 9404 public TbodyTagOpenContext tbodyTagOpen(int i) { 9405 return getRuleContext(TbodyTagOpenContext.class,i); 9406 } 9407 public List<TheadTagOpenContext> theadTagOpen() { 9408 return getRuleContexts(TheadTagOpenContext.class); 9409 } 9410 public TheadTagOpenContext theadTagOpen(int i) { 9411 return getRuleContext(TheadTagOpenContext.class,i); 9412 } 9413 public List<TfootTagOpenContext> tfootTagOpen() { 9414 return getRuleContexts(TfootTagOpenContext.class); 9415 } 9416 public TfootTagOpenContext tfootTagOpen(int i) { 9417 return getRuleContext(TfootTagOpenContext.class,i); 9418 } 9419 public List<HtmlCommentContext> htmlComment() { 9420 return getRuleContexts(HtmlCommentContext.class); 9421 } 9422 public HtmlCommentContext htmlComment(int i) { 9423 return getRuleContext(HtmlCommentContext.class,i); 9424 } 9425 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9426 public TerminalNode CDATA(int i) { 9427 return getToken(JavadocParser.CDATA, i); 9428 } 9429 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9430 public TerminalNode NEWLINE(int i) { 9431 return getToken(JavadocParser.NEWLINE, i); 9432 } 9433 public List<TextContext> text() { 9434 return getRuleContexts(TextContext.class); 9435 } 9436 public TextContext text(int i) { 9437 return getRuleContext(TextContext.class,i); 9438 } 9439 public List<JavadocInlineTagContext> javadocInlineTag() { 9440 return getRuleContexts(JavadocInlineTagContext.class); 9441 } 9442 public JavadocInlineTagContext javadocInlineTag(int i) { 9443 return getRuleContext(JavadocInlineTagContext.class,i); 9444 } 9445 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9446 public TerminalNode LEADING_ASTERISK(int i) { 9447 return getToken(JavadocParser.LEADING_ASTERISK, i); 9448 } 9449 public OptionContext(ParserRuleContext parent, int invokingState) { 9450 super(parent, invokingState); 9451 } 9452 @Override public int getRuleIndex() { return RULE_option; } 9453 @Override 9454 public void enterRule(ParseTreeListener listener) { 9455 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9456 } 9457 @Override 9458 public void exitRule(ParseTreeListener listener) { 9459 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9460 } 9461 @Override 9462 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9463 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9464 else return visitor.visitChildren(this); 9465 } 9466 } 9467 9468 public final OptionContext option() throws RecognitionException { 9469 OptionContext _localctx = new OptionContext(_ctx, getState()); 9470 enterRule(_localctx, 82, RULE_option); 9471 try { 9472 int _alt; 9473 enterOuterAlt(_localctx, 1); 9474 { 9475 setState(1089); 9476 optionTagOpen(); 9477 setState(1129); 9478 _errHandler.sync(this); 9479 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9480 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9481 if ( _alt==1 ) { 9482 { 9483 setState(1127); 9484 _errHandler.sync(this); 9485 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9486 case 1: 9487 { 9488 setState(1090); 9489 htmlTag(); 9490 } 9491 break; 9492 case 2: 9493 { 9494 setState(1091); 9495 singletonTag(); 9496 } 9497 break; 9498 case 3: 9499 { 9500 setState(1092); 9501 paragraph(); 9502 } 9503 break; 9504 case 4: 9505 { 9506 setState(1093); 9507 li(); 9508 } 9509 break; 9510 case 5: 9511 { 9512 setState(1094); 9513 tr(); 9514 } 9515 break; 9516 case 6: 9517 { 9518 setState(1095); 9519 td(); 9520 } 9521 break; 9522 case 7: 9523 { 9524 setState(1096); 9525 th(); 9526 } 9527 break; 9528 case 8: 9529 { 9530 setState(1097); 9531 body(); 9532 } 9533 break; 9534 case 9: 9535 { 9536 setState(1098); 9537 colgroup(); 9538 } 9539 break; 9540 case 10: 9541 { 9542 setState(1099); 9543 dd(); 9544 } 9545 break; 9546 case 11: 9547 { 9548 setState(1100); 9549 dt(); 9550 } 9551 break; 9552 case 12: 9553 { 9554 setState(1101); 9555 head(); 9556 } 9557 break; 9558 case 13: 9559 { 9560 setState(1102); 9561 html(); 9562 } 9563 break; 9564 case 14: 9565 { 9566 setState(1103); 9567 tbody(); 9568 } 9569 break; 9570 case 15: 9571 { 9572 setState(1104); 9573 thead(); 9574 } 9575 break; 9576 case 16: 9577 { 9578 setState(1105); 9579 tfoot(); 9580 } 9581 break; 9582 case 17: 9583 { 9584 setState(1106); 9585 pTagOpen(); 9586 } 9587 break; 9588 case 18: 9589 { 9590 setState(1107); 9591 liTagOpen(); 9592 } 9593 break; 9594 case 19: 9595 { 9596 setState(1108); 9597 trTagOpen(); 9598 } 9599 break; 9600 case 20: 9601 { 9602 setState(1109); 9603 tdTagOpen(); 9604 } 9605 break; 9606 case 21: 9607 { 9608 setState(1110); 9609 thTagOpen(); 9610 } 9611 break; 9612 case 22: 9613 { 9614 setState(1111); 9615 bodyTagOpen(); 9616 } 9617 break; 9618 case 23: 9619 { 9620 setState(1112); 9621 colgroupTagOpen(); 9622 } 9623 break; 9624 case 24: 9625 { 9626 setState(1113); 9627 ddTagOpen(); 9628 } 9629 break; 9630 case 25: 9631 { 9632 setState(1114); 9633 dtTagOpen(); 9634 } 9635 break; 9636 case 26: 9637 { 9638 setState(1115); 9639 headTagOpen(); 9640 } 9641 break; 9642 case 27: 9643 { 9644 setState(1116); 9645 htmlTagOpen(); 9646 } 9647 break; 9648 case 28: 9649 { 9650 setState(1117); 9651 tbodyTagOpen(); 9652 } 9653 break; 9654 case 29: 9655 { 9656 setState(1118); 9657 theadTagOpen(); 9658 } 9659 break; 9660 case 30: 9661 { 9662 setState(1119); 9663 tfootTagOpen(); 9664 } 9665 break; 9666 case 31: 9667 { 9668 { 9669 setState(1120); 9670 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9671 setState(1121); 9672 match(LEADING_ASTERISK); 9673 } 9674 } 9675 break; 9676 case 32: 9677 { 9678 setState(1122); 9679 htmlComment(); 9680 } 9681 break; 9682 case 33: 9683 { 9684 setState(1123); 9685 match(CDATA); 9686 } 9687 break; 9688 case 34: 9689 { 9690 setState(1124); 9691 match(NEWLINE); 9692 } 9693 break; 9694 case 35: 9695 { 9696 setState(1125); 9697 text(); 9698 } 9699 break; 9700 case 36: 9701 { 9702 setState(1126); 9703 javadocInlineTag(); 9704 } 9705 break; 9706 } 9707 } 9708 } 9709 setState(1131); 9710 _errHandler.sync(this); 9711 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9712 } 9713 setState(1132); 9714 optionTagClose(); 9715 } 9716 } 9717 catch (RecognitionException re) { 9718 _localctx.exception = re; 9719 _errHandler.reportError(this, re); 9720 _errHandler.recover(this, re); 9721 } 9722 finally { 9723 exitRule(); 9724 } 9725 return _localctx; 9726 } 9727 9728 public static class TbodyTagOpenContext extends ParserRuleContext { 9729 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9730 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9731 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9732 public List<AttributeContext> attribute() { 9733 return getRuleContexts(AttributeContext.class); 9734 } 9735 public AttributeContext attribute(int i) { 9736 return getRuleContext(AttributeContext.class,i); 9737 } 9738 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9739 public TerminalNode NEWLINE(int i) { 9740 return getToken(JavadocParser.NEWLINE, i); 9741 } 9742 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9743 public TerminalNode LEADING_ASTERISK(int i) { 9744 return getToken(JavadocParser.LEADING_ASTERISK, i); 9745 } 9746 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9747 public TerminalNode WS(int i) { 9748 return getToken(JavadocParser.WS, i); 9749 } 9750 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9751 super(parent, invokingState); 9752 } 9753 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9754 @Override 9755 public void enterRule(ParseTreeListener listener) { 9756 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9757 } 9758 @Override 9759 public void exitRule(ParseTreeListener listener) { 9760 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9761 } 9762 @Override 9763 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9764 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9765 else return visitor.visitChildren(this); 9766 } 9767 } 9768 9769 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9770 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9771 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9772 int _la; 9773 try { 9774 enterOuterAlt(_localctx, 1); 9775 { 9776 setState(1134); 9777 match(OPEN); 9778 setState(1135); 9779 match(TBODY_HTML_TAG_NAME); 9780 setState(1142); 9781 _errHandler.sync(this); 9782 _la = _input.LA(1); 9783 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9784 { 9785 setState(1140); 9786 _errHandler.sync(this); 9787 switch (_input.LA(1)) { 9788 case HTML_TAG_NAME: 9789 { 9790 setState(1136); 9791 attribute(); 9792 } 9793 break; 9794 case NEWLINE: 9795 { 9796 setState(1137); 9797 match(NEWLINE); 9798 } 9799 break; 9800 case LEADING_ASTERISK: 9801 { 9802 setState(1138); 9803 match(LEADING_ASTERISK); 9804 } 9805 break; 9806 case WS: 9807 { 9808 setState(1139); 9809 match(WS); 9810 } 9811 break; 9812 default: 9813 throw new NoViableAltException(this); 9814 } 9815 } 9816 setState(1144); 9817 _errHandler.sync(this); 9818 _la = _input.LA(1); 9819 } 9820 setState(1145); 9821 match(CLOSE); 9822 } 9823 } 9824 catch (RecognitionException re) { 9825 _localctx.exception = re; 9826 _errHandler.reportError(this, re); 9827 _errHandler.recover(this, re); 9828 } 9829 finally { 9830 exitRule(); 9831 } 9832 return _localctx; 9833 } 9834 9835 public static class TbodyTagCloseContext extends ParserRuleContext { 9836 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9837 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9838 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9839 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9840 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9841 public TerminalNode NEWLINE(int i) { 9842 return getToken(JavadocParser.NEWLINE, i); 9843 } 9844 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9845 public TerminalNode LEADING_ASTERISK(int i) { 9846 return getToken(JavadocParser.LEADING_ASTERISK, i); 9847 } 9848 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9849 public TerminalNode WS(int i) { 9850 return getToken(JavadocParser.WS, i); 9851 } 9852 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9853 super(parent, invokingState); 9854 } 9855 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9856 @Override 9857 public void enterRule(ParseTreeListener listener) { 9858 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9859 } 9860 @Override 9861 public void exitRule(ParseTreeListener listener) { 9862 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9863 } 9864 @Override 9865 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9866 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9867 else return visitor.visitChildren(this); 9868 } 9869 } 9870 9871 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9872 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9873 enterRule(_localctx, 86, RULE_tbodyTagClose); 9874 int _la; 9875 try { 9876 enterOuterAlt(_localctx, 1); 9877 { 9878 setState(1147); 9879 match(OPEN); 9880 setState(1148); 9881 match(SLASH); 9882 setState(1149); 9883 match(TBODY_HTML_TAG_NAME); 9884 setState(1153); 9885 _errHandler.sync(this); 9886 _la = _input.LA(1); 9887 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9888 { 9889 { 9890 setState(1150); 9891 _la = _input.LA(1); 9892 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9893 _errHandler.recoverInline(this); 9894 } 9895 else { 9896 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9897 _errHandler.reportMatch(this); 9898 consume(); 9899 } 9900 } 9901 } 9902 setState(1155); 9903 _errHandler.sync(this); 9904 _la = _input.LA(1); 9905 } 9906 setState(1156); 9907 match(CLOSE); 9908 } 9909 } 9910 catch (RecognitionException re) { 9911 _localctx.exception = re; 9912 _errHandler.reportError(this, re); 9913 _errHandler.recover(this, re); 9914 } 9915 finally { 9916 exitRule(); 9917 } 9918 return _localctx; 9919 } 9920 9921 public static class TbodyContext extends ParserRuleContext { 9922 public TbodyTagOpenContext tbodyTagOpen() { 9923 return getRuleContext(TbodyTagOpenContext.class,0); 9924 } 9925 public TbodyTagCloseContext tbodyTagClose() { 9926 return getRuleContext(TbodyTagCloseContext.class,0); 9927 } 9928 public List<HtmlTagContext> htmlTag() { 9929 return getRuleContexts(HtmlTagContext.class); 9930 } 9931 public HtmlTagContext htmlTag(int i) { 9932 return getRuleContext(HtmlTagContext.class,i); 9933 } 9934 public List<SingletonTagContext> singletonTag() { 9935 return getRuleContexts(SingletonTagContext.class); 9936 } 9937 public SingletonTagContext singletonTag(int i) { 9938 return getRuleContext(SingletonTagContext.class,i); 9939 } 9940 public List<ParagraphContext> paragraph() { 9941 return getRuleContexts(ParagraphContext.class); 9942 } 9943 public ParagraphContext paragraph(int i) { 9944 return getRuleContext(ParagraphContext.class,i); 9945 } 9946 public List<LiContext> li() { 9947 return getRuleContexts(LiContext.class); 9948 } 9949 public LiContext li(int i) { 9950 return getRuleContext(LiContext.class,i); 9951 } 9952 public List<TrContext> tr() { 9953 return getRuleContexts(TrContext.class); 9954 } 9955 public TrContext tr(int i) { 9956 return getRuleContext(TrContext.class,i); 9957 } 9958 public List<TdContext> td() { 9959 return getRuleContexts(TdContext.class); 9960 } 9961 public TdContext td(int i) { 9962 return getRuleContext(TdContext.class,i); 9963 } 9964 public List<ThContext> th() { 9965 return getRuleContexts(ThContext.class); 9966 } 9967 public ThContext th(int i) { 9968 return getRuleContext(ThContext.class,i); 9969 } 9970 public List<BodyContext> body() { 9971 return getRuleContexts(BodyContext.class); 9972 } 9973 public BodyContext body(int i) { 9974 return getRuleContext(BodyContext.class,i); 9975 } 9976 public List<ColgroupContext> colgroup() { 9977 return getRuleContexts(ColgroupContext.class); 9978 } 9979 public ColgroupContext colgroup(int i) { 9980 return getRuleContext(ColgroupContext.class,i); 9981 } 9982 public List<DdContext> dd() { 9983 return getRuleContexts(DdContext.class); 9984 } 9985 public DdContext dd(int i) { 9986 return getRuleContext(DdContext.class,i); 9987 } 9988 public List<DtContext> dt() { 9989 return getRuleContexts(DtContext.class); 9990 } 9991 public DtContext dt(int i) { 9992 return getRuleContext(DtContext.class,i); 9993 } 9994 public List<HeadContext> head() { 9995 return getRuleContexts(HeadContext.class); 9996 } 9997 public HeadContext head(int i) { 9998 return getRuleContext(HeadContext.class,i); 9999 } 10000 public List<HtmlContext> html() { 10001 return getRuleContexts(HtmlContext.class); 10002 } 10003 public HtmlContext html(int i) { 10004 return getRuleContext(HtmlContext.class,i); 10005 } 10006 public List<OptionContext> option() { 10007 return getRuleContexts(OptionContext.class); 10008 } 10009 public OptionContext option(int i) { 10010 return getRuleContext(OptionContext.class,i); 10011 } 10012 public List<TheadContext> thead() { 10013 return getRuleContexts(TheadContext.class); 10014 } 10015 public TheadContext thead(int i) { 10016 return getRuleContext(TheadContext.class,i); 10017 } 10018 public List<TfootContext> tfoot() { 10019 return getRuleContexts(TfootContext.class); 10020 } 10021 public TfootContext tfoot(int i) { 10022 return getRuleContext(TfootContext.class,i); 10023 } 10024 public List<PTagOpenContext> pTagOpen() { 10025 return getRuleContexts(PTagOpenContext.class); 10026 } 10027 public PTagOpenContext pTagOpen(int i) { 10028 return getRuleContext(PTagOpenContext.class,i); 10029 } 10030 public List<LiTagOpenContext> liTagOpen() { 10031 return getRuleContexts(LiTagOpenContext.class); 10032 } 10033 public LiTagOpenContext liTagOpen(int i) { 10034 return getRuleContext(LiTagOpenContext.class,i); 10035 } 10036 public List<TrTagOpenContext> trTagOpen() { 10037 return getRuleContexts(TrTagOpenContext.class); 10038 } 10039 public TrTagOpenContext trTagOpen(int i) { 10040 return getRuleContext(TrTagOpenContext.class,i); 10041 } 10042 public List<TdTagOpenContext> tdTagOpen() { 10043 return getRuleContexts(TdTagOpenContext.class); 10044 } 10045 public TdTagOpenContext tdTagOpen(int i) { 10046 return getRuleContext(TdTagOpenContext.class,i); 10047 } 10048 public List<ThTagOpenContext> thTagOpen() { 10049 return getRuleContexts(ThTagOpenContext.class); 10050 } 10051 public ThTagOpenContext thTagOpen(int i) { 10052 return getRuleContext(ThTagOpenContext.class,i); 10053 } 10054 public List<BodyTagOpenContext> bodyTagOpen() { 10055 return getRuleContexts(BodyTagOpenContext.class); 10056 } 10057 public BodyTagOpenContext bodyTagOpen(int i) { 10058 return getRuleContext(BodyTagOpenContext.class,i); 10059 } 10060 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10061 return getRuleContexts(ColgroupTagOpenContext.class); 10062 } 10063 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10064 return getRuleContext(ColgroupTagOpenContext.class,i); 10065 } 10066 public List<DdTagOpenContext> ddTagOpen() { 10067 return getRuleContexts(DdTagOpenContext.class); 10068 } 10069 public DdTagOpenContext ddTagOpen(int i) { 10070 return getRuleContext(DdTagOpenContext.class,i); 10071 } 10072 public List<DtTagOpenContext> dtTagOpen() { 10073 return getRuleContexts(DtTagOpenContext.class); 10074 } 10075 public DtTagOpenContext dtTagOpen(int i) { 10076 return getRuleContext(DtTagOpenContext.class,i); 10077 } 10078 public List<HeadTagOpenContext> headTagOpen() { 10079 return getRuleContexts(HeadTagOpenContext.class); 10080 } 10081 public HeadTagOpenContext headTagOpen(int i) { 10082 return getRuleContext(HeadTagOpenContext.class,i); 10083 } 10084 public List<HtmlTagOpenContext> htmlTagOpen() { 10085 return getRuleContexts(HtmlTagOpenContext.class); 10086 } 10087 public HtmlTagOpenContext htmlTagOpen(int i) { 10088 return getRuleContext(HtmlTagOpenContext.class,i); 10089 } 10090 public List<OptionTagOpenContext> optionTagOpen() { 10091 return getRuleContexts(OptionTagOpenContext.class); 10092 } 10093 public OptionTagOpenContext optionTagOpen(int i) { 10094 return getRuleContext(OptionTagOpenContext.class,i); 10095 } 10096 public List<TheadTagOpenContext> theadTagOpen() { 10097 return getRuleContexts(TheadTagOpenContext.class); 10098 } 10099 public TheadTagOpenContext theadTagOpen(int i) { 10100 return getRuleContext(TheadTagOpenContext.class,i); 10101 } 10102 public List<TfootTagOpenContext> tfootTagOpen() { 10103 return getRuleContexts(TfootTagOpenContext.class); 10104 } 10105 public TfootTagOpenContext tfootTagOpen(int i) { 10106 return getRuleContext(TfootTagOpenContext.class,i); 10107 } 10108 public List<HtmlCommentContext> htmlComment() { 10109 return getRuleContexts(HtmlCommentContext.class); 10110 } 10111 public HtmlCommentContext htmlComment(int i) { 10112 return getRuleContext(HtmlCommentContext.class,i); 10113 } 10114 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10115 public TerminalNode CDATA(int i) { 10116 return getToken(JavadocParser.CDATA, i); 10117 } 10118 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10119 public TerminalNode NEWLINE(int i) { 10120 return getToken(JavadocParser.NEWLINE, i); 10121 } 10122 public List<TextContext> text() { 10123 return getRuleContexts(TextContext.class); 10124 } 10125 public TextContext text(int i) { 10126 return getRuleContext(TextContext.class,i); 10127 } 10128 public List<JavadocInlineTagContext> javadocInlineTag() { 10129 return getRuleContexts(JavadocInlineTagContext.class); 10130 } 10131 public JavadocInlineTagContext javadocInlineTag(int i) { 10132 return getRuleContext(JavadocInlineTagContext.class,i); 10133 } 10134 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10135 public TerminalNode LEADING_ASTERISK(int i) { 10136 return getToken(JavadocParser.LEADING_ASTERISK, i); 10137 } 10138 public TbodyContext(ParserRuleContext parent, int invokingState) { 10139 super(parent, invokingState); 10140 } 10141 @Override public int getRuleIndex() { return RULE_tbody; } 10142 @Override 10143 public void enterRule(ParseTreeListener listener) { 10144 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10145 } 10146 @Override 10147 public void exitRule(ParseTreeListener listener) { 10148 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10149 } 10150 @Override 10151 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10152 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10153 else return visitor.visitChildren(this); 10154 } 10155 } 10156 10157 public final TbodyContext tbody() throws RecognitionException { 10158 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10159 enterRule(_localctx, 88, RULE_tbody); 10160 try { 10161 int _alt; 10162 enterOuterAlt(_localctx, 1); 10163 { 10164 setState(1158); 10165 tbodyTagOpen(); 10166 setState(1198); 10167 _errHandler.sync(this); 10168 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10169 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10170 if ( _alt==1 ) { 10171 { 10172 setState(1196); 10173 _errHandler.sync(this); 10174 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10175 case 1: 10176 { 10177 setState(1159); 10178 htmlTag(); 10179 } 10180 break; 10181 case 2: 10182 { 10183 setState(1160); 10184 singletonTag(); 10185 } 10186 break; 10187 case 3: 10188 { 10189 setState(1161); 10190 paragraph(); 10191 } 10192 break; 10193 case 4: 10194 { 10195 setState(1162); 10196 li(); 10197 } 10198 break; 10199 case 5: 10200 { 10201 setState(1163); 10202 tr(); 10203 } 10204 break; 10205 case 6: 10206 { 10207 setState(1164); 10208 td(); 10209 } 10210 break; 10211 case 7: 10212 { 10213 setState(1165); 10214 th(); 10215 } 10216 break; 10217 case 8: 10218 { 10219 setState(1166); 10220 body(); 10221 } 10222 break; 10223 case 9: 10224 { 10225 setState(1167); 10226 colgroup(); 10227 } 10228 break; 10229 case 10: 10230 { 10231 setState(1168); 10232 dd(); 10233 } 10234 break; 10235 case 11: 10236 { 10237 setState(1169); 10238 dt(); 10239 } 10240 break; 10241 case 12: 10242 { 10243 setState(1170); 10244 head(); 10245 } 10246 break; 10247 case 13: 10248 { 10249 setState(1171); 10250 html(); 10251 } 10252 break; 10253 case 14: 10254 { 10255 setState(1172); 10256 option(); 10257 } 10258 break; 10259 case 15: 10260 { 10261 setState(1173); 10262 thead(); 10263 } 10264 break; 10265 case 16: 10266 { 10267 setState(1174); 10268 tfoot(); 10269 } 10270 break; 10271 case 17: 10272 { 10273 setState(1175); 10274 pTagOpen(); 10275 } 10276 break; 10277 case 18: 10278 { 10279 setState(1176); 10280 liTagOpen(); 10281 } 10282 break; 10283 case 19: 10284 { 10285 setState(1177); 10286 trTagOpen(); 10287 } 10288 break; 10289 case 20: 10290 { 10291 setState(1178); 10292 tdTagOpen(); 10293 } 10294 break; 10295 case 21: 10296 { 10297 setState(1179); 10298 thTagOpen(); 10299 } 10300 break; 10301 case 22: 10302 { 10303 setState(1180); 10304 bodyTagOpen(); 10305 } 10306 break; 10307 case 23: 10308 { 10309 setState(1181); 10310 colgroupTagOpen(); 10311 } 10312 break; 10313 case 24: 10314 { 10315 setState(1182); 10316 ddTagOpen(); 10317 } 10318 break; 10319 case 25: 10320 { 10321 setState(1183); 10322 dtTagOpen(); 10323 } 10324 break; 10325 case 26: 10326 { 10327 setState(1184); 10328 headTagOpen(); 10329 } 10330 break; 10331 case 27: 10332 { 10333 setState(1185); 10334 htmlTagOpen(); 10335 } 10336 break; 10337 case 28: 10338 { 10339 setState(1186); 10340 optionTagOpen(); 10341 } 10342 break; 10343 case 29: 10344 { 10345 setState(1187); 10346 theadTagOpen(); 10347 } 10348 break; 10349 case 30: 10350 { 10351 setState(1188); 10352 tfootTagOpen(); 10353 } 10354 break; 10355 case 31: 10356 { 10357 { 10358 setState(1189); 10359 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10360 setState(1190); 10361 match(LEADING_ASTERISK); 10362 } 10363 } 10364 break; 10365 case 32: 10366 { 10367 setState(1191); 10368 htmlComment(); 10369 } 10370 break; 10371 case 33: 10372 { 10373 setState(1192); 10374 match(CDATA); 10375 } 10376 break; 10377 case 34: 10378 { 10379 setState(1193); 10380 match(NEWLINE); 10381 } 10382 break; 10383 case 35: 10384 { 10385 setState(1194); 10386 text(); 10387 } 10388 break; 10389 case 36: 10390 { 10391 setState(1195); 10392 javadocInlineTag(); 10393 } 10394 break; 10395 } 10396 } 10397 } 10398 setState(1200); 10399 _errHandler.sync(this); 10400 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10401 } 10402 setState(1201); 10403 tbodyTagClose(); 10404 } 10405 } 10406 catch (RecognitionException re) { 10407 _localctx.exception = re; 10408 _errHandler.reportError(this, re); 10409 _errHandler.recover(this, re); 10410 } 10411 finally { 10412 exitRule(); 10413 } 10414 return _localctx; 10415 } 10416 10417 public static class TfootTagOpenContext extends ParserRuleContext { 10418 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10419 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10420 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10421 public List<AttributeContext> attribute() { 10422 return getRuleContexts(AttributeContext.class); 10423 } 10424 public AttributeContext attribute(int i) { 10425 return getRuleContext(AttributeContext.class,i); 10426 } 10427 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10428 public TerminalNode NEWLINE(int i) { 10429 return getToken(JavadocParser.NEWLINE, i); 10430 } 10431 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10432 public TerminalNode LEADING_ASTERISK(int i) { 10433 return getToken(JavadocParser.LEADING_ASTERISK, i); 10434 } 10435 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10436 public TerminalNode WS(int i) { 10437 return getToken(JavadocParser.WS, i); 10438 } 10439 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10440 super(parent, invokingState); 10441 } 10442 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10443 @Override 10444 public void enterRule(ParseTreeListener listener) { 10445 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10446 } 10447 @Override 10448 public void exitRule(ParseTreeListener listener) { 10449 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10450 } 10451 @Override 10452 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10453 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10454 else return visitor.visitChildren(this); 10455 } 10456 } 10457 10458 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10459 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10460 enterRule(_localctx, 90, RULE_tfootTagOpen); 10461 int _la; 10462 try { 10463 enterOuterAlt(_localctx, 1); 10464 { 10465 setState(1203); 10466 match(OPEN); 10467 setState(1204); 10468 match(TFOOT_HTML_TAG_NAME); 10469 setState(1211); 10470 _errHandler.sync(this); 10471 _la = _input.LA(1); 10472 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10473 { 10474 setState(1209); 10475 _errHandler.sync(this); 10476 switch (_input.LA(1)) { 10477 case HTML_TAG_NAME: 10478 { 10479 setState(1205); 10480 attribute(); 10481 } 10482 break; 10483 case NEWLINE: 10484 { 10485 setState(1206); 10486 match(NEWLINE); 10487 } 10488 break; 10489 case LEADING_ASTERISK: 10490 { 10491 setState(1207); 10492 match(LEADING_ASTERISK); 10493 } 10494 break; 10495 case WS: 10496 { 10497 setState(1208); 10498 match(WS); 10499 } 10500 break; 10501 default: 10502 throw new NoViableAltException(this); 10503 } 10504 } 10505 setState(1213); 10506 _errHandler.sync(this); 10507 _la = _input.LA(1); 10508 } 10509 setState(1214); 10510 match(CLOSE); 10511 } 10512 } 10513 catch (RecognitionException re) { 10514 _localctx.exception = re; 10515 _errHandler.reportError(this, re); 10516 _errHandler.recover(this, re); 10517 } 10518 finally { 10519 exitRule(); 10520 } 10521 return _localctx; 10522 } 10523 10524 public static class TfootTagCloseContext extends ParserRuleContext { 10525 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10526 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10527 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10528 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10529 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10530 public TerminalNode NEWLINE(int i) { 10531 return getToken(JavadocParser.NEWLINE, i); 10532 } 10533 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10534 public TerminalNode LEADING_ASTERISK(int i) { 10535 return getToken(JavadocParser.LEADING_ASTERISK, i); 10536 } 10537 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10538 public TerminalNode WS(int i) { 10539 return getToken(JavadocParser.WS, i); 10540 } 10541 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10542 super(parent, invokingState); 10543 } 10544 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10545 @Override 10546 public void enterRule(ParseTreeListener listener) { 10547 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10548 } 10549 @Override 10550 public void exitRule(ParseTreeListener listener) { 10551 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10552 } 10553 @Override 10554 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10555 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10556 else return visitor.visitChildren(this); 10557 } 10558 } 10559 10560 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10561 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10562 enterRule(_localctx, 92, RULE_tfootTagClose); 10563 int _la; 10564 try { 10565 enterOuterAlt(_localctx, 1); 10566 { 10567 setState(1216); 10568 match(OPEN); 10569 setState(1217); 10570 match(SLASH); 10571 setState(1218); 10572 match(TFOOT_HTML_TAG_NAME); 10573 setState(1222); 10574 _errHandler.sync(this); 10575 _la = _input.LA(1); 10576 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10577 { 10578 { 10579 setState(1219); 10580 _la = _input.LA(1); 10581 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10582 _errHandler.recoverInline(this); 10583 } 10584 else { 10585 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10586 _errHandler.reportMatch(this); 10587 consume(); 10588 } 10589 } 10590 } 10591 setState(1224); 10592 _errHandler.sync(this); 10593 _la = _input.LA(1); 10594 } 10595 setState(1225); 10596 match(CLOSE); 10597 } 10598 } 10599 catch (RecognitionException re) { 10600 _localctx.exception = re; 10601 _errHandler.reportError(this, re); 10602 _errHandler.recover(this, re); 10603 } 10604 finally { 10605 exitRule(); 10606 } 10607 return _localctx; 10608 } 10609 10610 public static class TfootContext extends ParserRuleContext { 10611 public TfootTagOpenContext tfootTagOpen() { 10612 return getRuleContext(TfootTagOpenContext.class,0); 10613 } 10614 public TfootTagCloseContext tfootTagClose() { 10615 return getRuleContext(TfootTagCloseContext.class,0); 10616 } 10617 public List<HtmlTagContext> htmlTag() { 10618 return getRuleContexts(HtmlTagContext.class); 10619 } 10620 public HtmlTagContext htmlTag(int i) { 10621 return getRuleContext(HtmlTagContext.class,i); 10622 } 10623 public List<SingletonTagContext> singletonTag() { 10624 return getRuleContexts(SingletonTagContext.class); 10625 } 10626 public SingletonTagContext singletonTag(int i) { 10627 return getRuleContext(SingletonTagContext.class,i); 10628 } 10629 public List<ParagraphContext> paragraph() { 10630 return getRuleContexts(ParagraphContext.class); 10631 } 10632 public ParagraphContext paragraph(int i) { 10633 return getRuleContext(ParagraphContext.class,i); 10634 } 10635 public List<LiContext> li() { 10636 return getRuleContexts(LiContext.class); 10637 } 10638 public LiContext li(int i) { 10639 return getRuleContext(LiContext.class,i); 10640 } 10641 public List<TrContext> tr() { 10642 return getRuleContexts(TrContext.class); 10643 } 10644 public TrContext tr(int i) { 10645 return getRuleContext(TrContext.class,i); 10646 } 10647 public List<TdContext> td() { 10648 return getRuleContexts(TdContext.class); 10649 } 10650 public TdContext td(int i) { 10651 return getRuleContext(TdContext.class,i); 10652 } 10653 public List<ThContext> th() { 10654 return getRuleContexts(ThContext.class); 10655 } 10656 public ThContext th(int i) { 10657 return getRuleContext(ThContext.class,i); 10658 } 10659 public List<BodyContext> body() { 10660 return getRuleContexts(BodyContext.class); 10661 } 10662 public BodyContext body(int i) { 10663 return getRuleContext(BodyContext.class,i); 10664 } 10665 public List<ColgroupContext> colgroup() { 10666 return getRuleContexts(ColgroupContext.class); 10667 } 10668 public ColgroupContext colgroup(int i) { 10669 return getRuleContext(ColgroupContext.class,i); 10670 } 10671 public List<DdContext> dd() { 10672 return getRuleContexts(DdContext.class); 10673 } 10674 public DdContext dd(int i) { 10675 return getRuleContext(DdContext.class,i); 10676 } 10677 public List<DtContext> dt() { 10678 return getRuleContexts(DtContext.class); 10679 } 10680 public DtContext dt(int i) { 10681 return getRuleContext(DtContext.class,i); 10682 } 10683 public List<HeadContext> head() { 10684 return getRuleContexts(HeadContext.class); 10685 } 10686 public HeadContext head(int i) { 10687 return getRuleContext(HeadContext.class,i); 10688 } 10689 public List<HtmlContext> html() { 10690 return getRuleContexts(HtmlContext.class); 10691 } 10692 public HtmlContext html(int i) { 10693 return getRuleContext(HtmlContext.class,i); 10694 } 10695 public List<OptionContext> option() { 10696 return getRuleContexts(OptionContext.class); 10697 } 10698 public OptionContext option(int i) { 10699 return getRuleContext(OptionContext.class,i); 10700 } 10701 public List<TbodyContext> tbody() { 10702 return getRuleContexts(TbodyContext.class); 10703 } 10704 public TbodyContext tbody(int i) { 10705 return getRuleContext(TbodyContext.class,i); 10706 } 10707 public List<TheadContext> thead() { 10708 return getRuleContexts(TheadContext.class); 10709 } 10710 public TheadContext thead(int i) { 10711 return getRuleContext(TheadContext.class,i); 10712 } 10713 public List<PTagOpenContext> pTagOpen() { 10714 return getRuleContexts(PTagOpenContext.class); 10715 } 10716 public PTagOpenContext pTagOpen(int i) { 10717 return getRuleContext(PTagOpenContext.class,i); 10718 } 10719 public List<LiTagOpenContext> liTagOpen() { 10720 return getRuleContexts(LiTagOpenContext.class); 10721 } 10722 public LiTagOpenContext liTagOpen(int i) { 10723 return getRuleContext(LiTagOpenContext.class,i); 10724 } 10725 public List<TrTagOpenContext> trTagOpen() { 10726 return getRuleContexts(TrTagOpenContext.class); 10727 } 10728 public TrTagOpenContext trTagOpen(int i) { 10729 return getRuleContext(TrTagOpenContext.class,i); 10730 } 10731 public List<TdTagOpenContext> tdTagOpen() { 10732 return getRuleContexts(TdTagOpenContext.class); 10733 } 10734 public TdTagOpenContext tdTagOpen(int i) { 10735 return getRuleContext(TdTagOpenContext.class,i); 10736 } 10737 public List<ThTagOpenContext> thTagOpen() { 10738 return getRuleContexts(ThTagOpenContext.class); 10739 } 10740 public ThTagOpenContext thTagOpen(int i) { 10741 return getRuleContext(ThTagOpenContext.class,i); 10742 } 10743 public List<BodyTagOpenContext> bodyTagOpen() { 10744 return getRuleContexts(BodyTagOpenContext.class); 10745 } 10746 public BodyTagOpenContext bodyTagOpen(int i) { 10747 return getRuleContext(BodyTagOpenContext.class,i); 10748 } 10749 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10750 return getRuleContexts(ColgroupTagOpenContext.class); 10751 } 10752 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10753 return getRuleContext(ColgroupTagOpenContext.class,i); 10754 } 10755 public List<DdTagOpenContext> ddTagOpen() { 10756 return getRuleContexts(DdTagOpenContext.class); 10757 } 10758 public DdTagOpenContext ddTagOpen(int i) { 10759 return getRuleContext(DdTagOpenContext.class,i); 10760 } 10761 public List<DtTagOpenContext> dtTagOpen() { 10762 return getRuleContexts(DtTagOpenContext.class); 10763 } 10764 public DtTagOpenContext dtTagOpen(int i) { 10765 return getRuleContext(DtTagOpenContext.class,i); 10766 } 10767 public List<HeadTagOpenContext> headTagOpen() { 10768 return getRuleContexts(HeadTagOpenContext.class); 10769 } 10770 public HeadTagOpenContext headTagOpen(int i) { 10771 return getRuleContext(HeadTagOpenContext.class,i); 10772 } 10773 public List<HtmlTagOpenContext> htmlTagOpen() { 10774 return getRuleContexts(HtmlTagOpenContext.class); 10775 } 10776 public HtmlTagOpenContext htmlTagOpen(int i) { 10777 return getRuleContext(HtmlTagOpenContext.class,i); 10778 } 10779 public List<OptionTagOpenContext> optionTagOpen() { 10780 return getRuleContexts(OptionTagOpenContext.class); 10781 } 10782 public OptionTagOpenContext optionTagOpen(int i) { 10783 return getRuleContext(OptionTagOpenContext.class,i); 10784 } 10785 public List<TbodyTagOpenContext> tbodyTagOpen() { 10786 return getRuleContexts(TbodyTagOpenContext.class); 10787 } 10788 public TbodyTagOpenContext tbodyTagOpen(int i) { 10789 return getRuleContext(TbodyTagOpenContext.class,i); 10790 } 10791 public List<TheadTagOpenContext> theadTagOpen() { 10792 return getRuleContexts(TheadTagOpenContext.class); 10793 } 10794 public TheadTagOpenContext theadTagOpen(int i) { 10795 return getRuleContext(TheadTagOpenContext.class,i); 10796 } 10797 public List<HtmlCommentContext> htmlComment() { 10798 return getRuleContexts(HtmlCommentContext.class); 10799 } 10800 public HtmlCommentContext htmlComment(int i) { 10801 return getRuleContext(HtmlCommentContext.class,i); 10802 } 10803 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10804 public TerminalNode CDATA(int i) { 10805 return getToken(JavadocParser.CDATA, i); 10806 } 10807 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10808 public TerminalNode NEWLINE(int i) { 10809 return getToken(JavadocParser.NEWLINE, i); 10810 } 10811 public List<TextContext> text() { 10812 return getRuleContexts(TextContext.class); 10813 } 10814 public TextContext text(int i) { 10815 return getRuleContext(TextContext.class,i); 10816 } 10817 public List<JavadocInlineTagContext> javadocInlineTag() { 10818 return getRuleContexts(JavadocInlineTagContext.class); 10819 } 10820 public JavadocInlineTagContext javadocInlineTag(int i) { 10821 return getRuleContext(JavadocInlineTagContext.class,i); 10822 } 10823 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10824 public TerminalNode LEADING_ASTERISK(int i) { 10825 return getToken(JavadocParser.LEADING_ASTERISK, i); 10826 } 10827 public TfootContext(ParserRuleContext parent, int invokingState) { 10828 super(parent, invokingState); 10829 } 10830 @Override public int getRuleIndex() { return RULE_tfoot; } 10831 @Override 10832 public void enterRule(ParseTreeListener listener) { 10833 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10834 } 10835 @Override 10836 public void exitRule(ParseTreeListener listener) { 10837 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10838 } 10839 @Override 10840 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10841 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10842 else return visitor.visitChildren(this); 10843 } 10844 } 10845 10846 public final TfootContext tfoot() throws RecognitionException { 10847 TfootContext _localctx = new TfootContext(_ctx, getState()); 10848 enterRule(_localctx, 94, RULE_tfoot); 10849 try { 10850 int _alt; 10851 enterOuterAlt(_localctx, 1); 10852 { 10853 setState(1227); 10854 tfootTagOpen(); 10855 setState(1267); 10856 _errHandler.sync(this); 10857 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10858 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10859 if ( _alt==1 ) { 10860 { 10861 setState(1265); 10862 _errHandler.sync(this); 10863 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10864 case 1: 10865 { 10866 setState(1228); 10867 htmlTag(); 10868 } 10869 break; 10870 case 2: 10871 { 10872 setState(1229); 10873 singletonTag(); 10874 } 10875 break; 10876 case 3: 10877 { 10878 setState(1230); 10879 paragraph(); 10880 } 10881 break; 10882 case 4: 10883 { 10884 setState(1231); 10885 li(); 10886 } 10887 break; 10888 case 5: 10889 { 10890 setState(1232); 10891 tr(); 10892 } 10893 break; 10894 case 6: 10895 { 10896 setState(1233); 10897 td(); 10898 } 10899 break; 10900 case 7: 10901 { 10902 setState(1234); 10903 th(); 10904 } 10905 break; 10906 case 8: 10907 { 10908 setState(1235); 10909 body(); 10910 } 10911 break; 10912 case 9: 10913 { 10914 setState(1236); 10915 colgroup(); 10916 } 10917 break; 10918 case 10: 10919 { 10920 setState(1237); 10921 dd(); 10922 } 10923 break; 10924 case 11: 10925 { 10926 setState(1238); 10927 dt(); 10928 } 10929 break; 10930 case 12: 10931 { 10932 setState(1239); 10933 head(); 10934 } 10935 break; 10936 case 13: 10937 { 10938 setState(1240); 10939 html(); 10940 } 10941 break; 10942 case 14: 10943 { 10944 setState(1241); 10945 option(); 10946 } 10947 break; 10948 case 15: 10949 { 10950 setState(1242); 10951 tbody(); 10952 } 10953 break; 10954 case 16: 10955 { 10956 setState(1243); 10957 thead(); 10958 } 10959 break; 10960 case 17: 10961 { 10962 setState(1244); 10963 pTagOpen(); 10964 } 10965 break; 10966 case 18: 10967 { 10968 setState(1245); 10969 liTagOpen(); 10970 } 10971 break; 10972 case 19: 10973 { 10974 setState(1246); 10975 trTagOpen(); 10976 } 10977 break; 10978 case 20: 10979 { 10980 setState(1247); 10981 tdTagOpen(); 10982 } 10983 break; 10984 case 21: 10985 { 10986 setState(1248); 10987 thTagOpen(); 10988 } 10989 break; 10990 case 22: 10991 { 10992 setState(1249); 10993 bodyTagOpen(); 10994 } 10995 break; 10996 case 23: 10997 { 10998 setState(1250); 10999 colgroupTagOpen(); 11000 } 11001 break; 11002 case 24: 11003 { 11004 setState(1251); 11005 ddTagOpen(); 11006 } 11007 break; 11008 case 25: 11009 { 11010 setState(1252); 11011 dtTagOpen(); 11012 } 11013 break; 11014 case 26: 11015 { 11016 setState(1253); 11017 headTagOpen(); 11018 } 11019 break; 11020 case 27: 11021 { 11022 setState(1254); 11023 htmlTagOpen(); 11024 } 11025 break; 11026 case 28: 11027 { 11028 setState(1255); 11029 optionTagOpen(); 11030 } 11031 break; 11032 case 29: 11033 { 11034 setState(1256); 11035 tbodyTagOpen(); 11036 } 11037 break; 11038 case 30: 11039 { 11040 setState(1257); 11041 theadTagOpen(); 11042 } 11043 break; 11044 case 31: 11045 { 11046 { 11047 setState(1258); 11048 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11049 setState(1259); 11050 match(LEADING_ASTERISK); 11051 } 11052 } 11053 break; 11054 case 32: 11055 { 11056 setState(1260); 11057 htmlComment(); 11058 } 11059 break; 11060 case 33: 11061 { 11062 setState(1261); 11063 match(CDATA); 11064 } 11065 break; 11066 case 34: 11067 { 11068 setState(1262); 11069 match(NEWLINE); 11070 } 11071 break; 11072 case 35: 11073 { 11074 setState(1263); 11075 text(); 11076 } 11077 break; 11078 case 36: 11079 { 11080 setState(1264); 11081 javadocInlineTag(); 11082 } 11083 break; 11084 } 11085 } 11086 } 11087 setState(1269); 11088 _errHandler.sync(this); 11089 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 11090 } 11091 setState(1270); 11092 tfootTagClose(); 11093 } 11094 } 11095 catch (RecognitionException re) { 11096 _localctx.exception = re; 11097 _errHandler.reportError(this, re); 11098 _errHandler.recover(this, re); 11099 } 11100 finally { 11101 exitRule(); 11102 } 11103 return _localctx; 11104 } 11105 11106 public static class TheadTagOpenContext extends ParserRuleContext { 11107 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11108 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11109 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11110 public List<AttributeContext> attribute() { 11111 return getRuleContexts(AttributeContext.class); 11112 } 11113 public AttributeContext attribute(int i) { 11114 return getRuleContext(AttributeContext.class,i); 11115 } 11116 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11117 public TerminalNode NEWLINE(int i) { 11118 return getToken(JavadocParser.NEWLINE, i); 11119 } 11120 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11121 public TerminalNode LEADING_ASTERISK(int i) { 11122 return getToken(JavadocParser.LEADING_ASTERISK, i); 11123 } 11124 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11125 public TerminalNode WS(int i) { 11126 return getToken(JavadocParser.WS, i); 11127 } 11128 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11129 super(parent, invokingState); 11130 } 11131 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11132 @Override 11133 public void enterRule(ParseTreeListener listener) { 11134 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11135 } 11136 @Override 11137 public void exitRule(ParseTreeListener listener) { 11138 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11139 } 11140 @Override 11141 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11142 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11143 else return visitor.visitChildren(this); 11144 } 11145 } 11146 11147 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11148 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11149 enterRule(_localctx, 96, RULE_theadTagOpen); 11150 int _la; 11151 try { 11152 enterOuterAlt(_localctx, 1); 11153 { 11154 setState(1272); 11155 match(OPEN); 11156 setState(1273); 11157 match(THEAD_HTML_TAG_NAME); 11158 setState(1280); 11159 _errHandler.sync(this); 11160 _la = _input.LA(1); 11161 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11162 { 11163 setState(1278); 11164 _errHandler.sync(this); 11165 switch (_input.LA(1)) { 11166 case HTML_TAG_NAME: 11167 { 11168 setState(1274); 11169 attribute(); 11170 } 11171 break; 11172 case NEWLINE: 11173 { 11174 setState(1275); 11175 match(NEWLINE); 11176 } 11177 break; 11178 case LEADING_ASTERISK: 11179 { 11180 setState(1276); 11181 match(LEADING_ASTERISK); 11182 } 11183 break; 11184 case WS: 11185 { 11186 setState(1277); 11187 match(WS); 11188 } 11189 break; 11190 default: 11191 throw new NoViableAltException(this); 11192 } 11193 } 11194 setState(1282); 11195 _errHandler.sync(this); 11196 _la = _input.LA(1); 11197 } 11198 setState(1283); 11199 match(CLOSE); 11200 } 11201 } 11202 catch (RecognitionException re) { 11203 _localctx.exception = re; 11204 _errHandler.reportError(this, re); 11205 _errHandler.recover(this, re); 11206 } 11207 finally { 11208 exitRule(); 11209 } 11210 return _localctx; 11211 } 11212 11213 public static class TheadTagCloseContext extends ParserRuleContext { 11214 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11215 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11216 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11217 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11218 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11219 public TerminalNode NEWLINE(int i) { 11220 return getToken(JavadocParser.NEWLINE, i); 11221 } 11222 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11223 public TerminalNode LEADING_ASTERISK(int i) { 11224 return getToken(JavadocParser.LEADING_ASTERISK, i); 11225 } 11226 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11227 public TerminalNode WS(int i) { 11228 return getToken(JavadocParser.WS, i); 11229 } 11230 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11231 super(parent, invokingState); 11232 } 11233 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11234 @Override 11235 public void enterRule(ParseTreeListener listener) { 11236 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11237 } 11238 @Override 11239 public void exitRule(ParseTreeListener listener) { 11240 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11241 } 11242 @Override 11243 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11244 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11245 else return visitor.visitChildren(this); 11246 } 11247 } 11248 11249 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11250 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11251 enterRule(_localctx, 98, RULE_theadTagClose); 11252 int _la; 11253 try { 11254 enterOuterAlt(_localctx, 1); 11255 { 11256 setState(1285); 11257 match(OPEN); 11258 setState(1286); 11259 match(SLASH); 11260 setState(1287); 11261 match(THEAD_HTML_TAG_NAME); 11262 setState(1291); 11263 _errHandler.sync(this); 11264 _la = _input.LA(1); 11265 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11266 { 11267 { 11268 setState(1288); 11269 _la = _input.LA(1); 11270 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11271 _errHandler.recoverInline(this); 11272 } 11273 else { 11274 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11275 _errHandler.reportMatch(this); 11276 consume(); 11277 } 11278 } 11279 } 11280 setState(1293); 11281 _errHandler.sync(this); 11282 _la = _input.LA(1); 11283 } 11284 setState(1294); 11285 match(CLOSE); 11286 } 11287 } 11288 catch (RecognitionException re) { 11289 _localctx.exception = re; 11290 _errHandler.reportError(this, re); 11291 _errHandler.recover(this, re); 11292 } 11293 finally { 11294 exitRule(); 11295 } 11296 return _localctx; 11297 } 11298 11299 public static class TheadContext extends ParserRuleContext { 11300 public TheadTagOpenContext theadTagOpen() { 11301 return getRuleContext(TheadTagOpenContext.class,0); 11302 } 11303 public TheadTagCloseContext theadTagClose() { 11304 return getRuleContext(TheadTagCloseContext.class,0); 11305 } 11306 public List<HtmlTagContext> htmlTag() { 11307 return getRuleContexts(HtmlTagContext.class); 11308 } 11309 public HtmlTagContext htmlTag(int i) { 11310 return getRuleContext(HtmlTagContext.class,i); 11311 } 11312 public List<SingletonTagContext> singletonTag() { 11313 return getRuleContexts(SingletonTagContext.class); 11314 } 11315 public SingletonTagContext singletonTag(int i) { 11316 return getRuleContext(SingletonTagContext.class,i); 11317 } 11318 public List<ParagraphContext> paragraph() { 11319 return getRuleContexts(ParagraphContext.class); 11320 } 11321 public ParagraphContext paragraph(int i) { 11322 return getRuleContext(ParagraphContext.class,i); 11323 } 11324 public List<LiContext> li() { 11325 return getRuleContexts(LiContext.class); 11326 } 11327 public LiContext li(int i) { 11328 return getRuleContext(LiContext.class,i); 11329 } 11330 public List<TrContext> tr() { 11331 return getRuleContexts(TrContext.class); 11332 } 11333 public TrContext tr(int i) { 11334 return getRuleContext(TrContext.class,i); 11335 } 11336 public List<TdContext> td() { 11337 return getRuleContexts(TdContext.class); 11338 } 11339 public TdContext td(int i) { 11340 return getRuleContext(TdContext.class,i); 11341 } 11342 public List<ThContext> th() { 11343 return getRuleContexts(ThContext.class); 11344 } 11345 public ThContext th(int i) { 11346 return getRuleContext(ThContext.class,i); 11347 } 11348 public List<BodyContext> body() { 11349 return getRuleContexts(BodyContext.class); 11350 } 11351 public BodyContext body(int i) { 11352 return getRuleContext(BodyContext.class,i); 11353 } 11354 public List<ColgroupContext> colgroup() { 11355 return getRuleContexts(ColgroupContext.class); 11356 } 11357 public ColgroupContext colgroup(int i) { 11358 return getRuleContext(ColgroupContext.class,i); 11359 } 11360 public List<DdContext> dd() { 11361 return getRuleContexts(DdContext.class); 11362 } 11363 public DdContext dd(int i) { 11364 return getRuleContext(DdContext.class,i); 11365 } 11366 public List<DtContext> dt() { 11367 return getRuleContexts(DtContext.class); 11368 } 11369 public DtContext dt(int i) { 11370 return getRuleContext(DtContext.class,i); 11371 } 11372 public List<HeadContext> head() { 11373 return getRuleContexts(HeadContext.class); 11374 } 11375 public HeadContext head(int i) { 11376 return getRuleContext(HeadContext.class,i); 11377 } 11378 public List<HtmlContext> html() { 11379 return getRuleContexts(HtmlContext.class); 11380 } 11381 public HtmlContext html(int i) { 11382 return getRuleContext(HtmlContext.class,i); 11383 } 11384 public List<OptionContext> option() { 11385 return getRuleContexts(OptionContext.class); 11386 } 11387 public OptionContext option(int i) { 11388 return getRuleContext(OptionContext.class,i); 11389 } 11390 public List<TbodyContext> tbody() { 11391 return getRuleContexts(TbodyContext.class); 11392 } 11393 public TbodyContext tbody(int i) { 11394 return getRuleContext(TbodyContext.class,i); 11395 } 11396 public List<TfootContext> tfoot() { 11397 return getRuleContexts(TfootContext.class); 11398 } 11399 public TfootContext tfoot(int i) { 11400 return getRuleContext(TfootContext.class,i); 11401 } 11402 public List<PTagOpenContext> pTagOpen() { 11403 return getRuleContexts(PTagOpenContext.class); 11404 } 11405 public PTagOpenContext pTagOpen(int i) { 11406 return getRuleContext(PTagOpenContext.class,i); 11407 } 11408 public List<LiTagOpenContext> liTagOpen() { 11409 return getRuleContexts(LiTagOpenContext.class); 11410 } 11411 public LiTagOpenContext liTagOpen(int i) { 11412 return getRuleContext(LiTagOpenContext.class,i); 11413 } 11414 public List<TrTagOpenContext> trTagOpen() { 11415 return getRuleContexts(TrTagOpenContext.class); 11416 } 11417 public TrTagOpenContext trTagOpen(int i) { 11418 return getRuleContext(TrTagOpenContext.class,i); 11419 } 11420 public List<TdTagOpenContext> tdTagOpen() { 11421 return getRuleContexts(TdTagOpenContext.class); 11422 } 11423 public TdTagOpenContext tdTagOpen(int i) { 11424 return getRuleContext(TdTagOpenContext.class,i); 11425 } 11426 public List<ThTagOpenContext> thTagOpen() { 11427 return getRuleContexts(ThTagOpenContext.class); 11428 } 11429 public ThTagOpenContext thTagOpen(int i) { 11430 return getRuleContext(ThTagOpenContext.class,i); 11431 } 11432 public List<BodyTagOpenContext> bodyTagOpen() { 11433 return getRuleContexts(BodyTagOpenContext.class); 11434 } 11435 public BodyTagOpenContext bodyTagOpen(int i) { 11436 return getRuleContext(BodyTagOpenContext.class,i); 11437 } 11438 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11439 return getRuleContexts(ColgroupTagOpenContext.class); 11440 } 11441 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11442 return getRuleContext(ColgroupTagOpenContext.class,i); 11443 } 11444 public List<DdTagOpenContext> ddTagOpen() { 11445 return getRuleContexts(DdTagOpenContext.class); 11446 } 11447 public DdTagOpenContext ddTagOpen(int i) { 11448 return getRuleContext(DdTagOpenContext.class,i); 11449 } 11450 public List<DtTagOpenContext> dtTagOpen() { 11451 return getRuleContexts(DtTagOpenContext.class); 11452 } 11453 public DtTagOpenContext dtTagOpen(int i) { 11454 return getRuleContext(DtTagOpenContext.class,i); 11455 } 11456 public List<HeadTagOpenContext> headTagOpen() { 11457 return getRuleContexts(HeadTagOpenContext.class); 11458 } 11459 public HeadTagOpenContext headTagOpen(int i) { 11460 return getRuleContext(HeadTagOpenContext.class,i); 11461 } 11462 public List<HtmlTagOpenContext> htmlTagOpen() { 11463 return getRuleContexts(HtmlTagOpenContext.class); 11464 } 11465 public HtmlTagOpenContext htmlTagOpen(int i) { 11466 return getRuleContext(HtmlTagOpenContext.class,i); 11467 } 11468 public List<OptionTagOpenContext> optionTagOpen() { 11469 return getRuleContexts(OptionTagOpenContext.class); 11470 } 11471 public OptionTagOpenContext optionTagOpen(int i) { 11472 return getRuleContext(OptionTagOpenContext.class,i); 11473 } 11474 public List<TbodyTagOpenContext> tbodyTagOpen() { 11475 return getRuleContexts(TbodyTagOpenContext.class); 11476 } 11477 public TbodyTagOpenContext tbodyTagOpen(int i) { 11478 return getRuleContext(TbodyTagOpenContext.class,i); 11479 } 11480 public List<TfootTagOpenContext> tfootTagOpen() { 11481 return getRuleContexts(TfootTagOpenContext.class); 11482 } 11483 public TfootTagOpenContext tfootTagOpen(int i) { 11484 return getRuleContext(TfootTagOpenContext.class,i); 11485 } 11486 public List<HtmlCommentContext> htmlComment() { 11487 return getRuleContexts(HtmlCommentContext.class); 11488 } 11489 public HtmlCommentContext htmlComment(int i) { 11490 return getRuleContext(HtmlCommentContext.class,i); 11491 } 11492 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11493 public TerminalNode CDATA(int i) { 11494 return getToken(JavadocParser.CDATA, i); 11495 } 11496 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11497 public TerminalNode NEWLINE(int i) { 11498 return getToken(JavadocParser.NEWLINE, i); 11499 } 11500 public List<TextContext> text() { 11501 return getRuleContexts(TextContext.class); 11502 } 11503 public TextContext text(int i) { 11504 return getRuleContext(TextContext.class,i); 11505 } 11506 public List<JavadocInlineTagContext> javadocInlineTag() { 11507 return getRuleContexts(JavadocInlineTagContext.class); 11508 } 11509 public JavadocInlineTagContext javadocInlineTag(int i) { 11510 return getRuleContext(JavadocInlineTagContext.class,i); 11511 } 11512 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11513 public TerminalNode LEADING_ASTERISK(int i) { 11514 return getToken(JavadocParser.LEADING_ASTERISK, i); 11515 } 11516 public TheadContext(ParserRuleContext parent, int invokingState) { 11517 super(parent, invokingState); 11518 } 11519 @Override public int getRuleIndex() { return RULE_thead; } 11520 @Override 11521 public void enterRule(ParseTreeListener listener) { 11522 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11523 } 11524 @Override 11525 public void exitRule(ParseTreeListener listener) { 11526 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11527 } 11528 @Override 11529 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11530 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11531 else return visitor.visitChildren(this); 11532 } 11533 } 11534 11535 public final TheadContext thead() throws RecognitionException { 11536 TheadContext _localctx = new TheadContext(_ctx, getState()); 11537 enterRule(_localctx, 100, RULE_thead); 11538 try { 11539 int _alt; 11540 enterOuterAlt(_localctx, 1); 11541 { 11542 setState(1296); 11543 theadTagOpen(); 11544 setState(1336); 11545 _errHandler.sync(this); 11546 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11547 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11548 if ( _alt==1 ) { 11549 { 11550 setState(1334); 11551 _errHandler.sync(this); 11552 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11553 case 1: 11554 { 11555 setState(1297); 11556 htmlTag(); 11557 } 11558 break; 11559 case 2: 11560 { 11561 setState(1298); 11562 singletonTag(); 11563 } 11564 break; 11565 case 3: 11566 { 11567 setState(1299); 11568 paragraph(); 11569 } 11570 break; 11571 case 4: 11572 { 11573 setState(1300); 11574 li(); 11575 } 11576 break; 11577 case 5: 11578 { 11579 setState(1301); 11580 tr(); 11581 } 11582 break; 11583 case 6: 11584 { 11585 setState(1302); 11586 td(); 11587 } 11588 break; 11589 case 7: 11590 { 11591 setState(1303); 11592 th(); 11593 } 11594 break; 11595 case 8: 11596 { 11597 setState(1304); 11598 body(); 11599 } 11600 break; 11601 case 9: 11602 { 11603 setState(1305); 11604 colgroup(); 11605 } 11606 break; 11607 case 10: 11608 { 11609 setState(1306); 11610 dd(); 11611 } 11612 break; 11613 case 11: 11614 { 11615 setState(1307); 11616 dt(); 11617 } 11618 break; 11619 case 12: 11620 { 11621 setState(1308); 11622 head(); 11623 } 11624 break; 11625 case 13: 11626 { 11627 setState(1309); 11628 html(); 11629 } 11630 break; 11631 case 14: 11632 { 11633 setState(1310); 11634 option(); 11635 } 11636 break; 11637 case 15: 11638 { 11639 setState(1311); 11640 tbody(); 11641 } 11642 break; 11643 case 16: 11644 { 11645 setState(1312); 11646 tfoot(); 11647 } 11648 break; 11649 case 17: 11650 { 11651 setState(1313); 11652 pTagOpen(); 11653 } 11654 break; 11655 case 18: 11656 { 11657 setState(1314); 11658 liTagOpen(); 11659 } 11660 break; 11661 case 19: 11662 { 11663 setState(1315); 11664 trTagOpen(); 11665 } 11666 break; 11667 case 20: 11668 { 11669 setState(1316); 11670 tdTagOpen(); 11671 } 11672 break; 11673 case 21: 11674 { 11675 setState(1317); 11676 thTagOpen(); 11677 } 11678 break; 11679 case 22: 11680 { 11681 setState(1318); 11682 bodyTagOpen(); 11683 } 11684 break; 11685 case 23: 11686 { 11687 setState(1319); 11688 colgroupTagOpen(); 11689 } 11690 break; 11691 case 24: 11692 { 11693 setState(1320); 11694 ddTagOpen(); 11695 } 11696 break; 11697 case 25: 11698 { 11699 setState(1321); 11700 dtTagOpen(); 11701 } 11702 break; 11703 case 26: 11704 { 11705 setState(1322); 11706 headTagOpen(); 11707 } 11708 break; 11709 case 27: 11710 { 11711 setState(1323); 11712 htmlTagOpen(); 11713 } 11714 break; 11715 case 28: 11716 { 11717 setState(1324); 11718 optionTagOpen(); 11719 } 11720 break; 11721 case 29: 11722 { 11723 setState(1325); 11724 tbodyTagOpen(); 11725 } 11726 break; 11727 case 30: 11728 { 11729 setState(1326); 11730 tfootTagOpen(); 11731 } 11732 break; 11733 case 31: 11734 { 11735 { 11736 setState(1327); 11737 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11738 setState(1328); 11739 match(LEADING_ASTERISK); 11740 } 11741 } 11742 break; 11743 case 32: 11744 { 11745 setState(1329); 11746 htmlComment(); 11747 } 11748 break; 11749 case 33: 11750 { 11751 setState(1330); 11752 match(CDATA); 11753 } 11754 break; 11755 case 34: 11756 { 11757 setState(1331); 11758 match(NEWLINE); 11759 } 11760 break; 11761 case 35: 11762 { 11763 setState(1332); 11764 text(); 11765 } 11766 break; 11767 case 36: 11768 { 11769 setState(1333); 11770 javadocInlineTag(); 11771 } 11772 break; 11773 } 11774 } 11775 } 11776 setState(1338); 11777 _errHandler.sync(this); 11778 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11779 } 11780 setState(1339); 11781 theadTagClose(); 11782 } 11783 } 11784 catch (RecognitionException re) { 11785 _localctx.exception = re; 11786 _errHandler.reportError(this, re); 11787 _errHandler.recover(this, re); 11788 } 11789 finally { 11790 exitRule(); 11791 } 11792 return _localctx; 11793 } 11794 11795 public static class SingletonElementContext extends ParserRuleContext { 11796 public SingletonTagContext singletonTag() { 11797 return getRuleContext(SingletonTagContext.class,0); 11798 } 11799 public AreaTagContext areaTag() { 11800 return getRuleContext(AreaTagContext.class,0); 11801 } 11802 public BaseTagContext baseTag() { 11803 return getRuleContext(BaseTagContext.class,0); 11804 } 11805 public BasefontTagContext basefontTag() { 11806 return getRuleContext(BasefontTagContext.class,0); 11807 } 11808 public BrTagContext brTag() { 11809 return getRuleContext(BrTagContext.class,0); 11810 } 11811 public ColTagContext colTag() { 11812 return getRuleContext(ColTagContext.class,0); 11813 } 11814 public FrameTagContext frameTag() { 11815 return getRuleContext(FrameTagContext.class,0); 11816 } 11817 public HrTagContext hrTag() { 11818 return getRuleContext(HrTagContext.class,0); 11819 } 11820 public ImgTagContext imgTag() { 11821 return getRuleContext(ImgTagContext.class,0); 11822 } 11823 public InputTagContext inputTag() { 11824 return getRuleContext(InputTagContext.class,0); 11825 } 11826 public IsindexTagContext isindexTag() { 11827 return getRuleContext(IsindexTagContext.class,0); 11828 } 11829 public LinkTagContext linkTag() { 11830 return getRuleContext(LinkTagContext.class,0); 11831 } 11832 public MetaTagContext metaTag() { 11833 return getRuleContext(MetaTagContext.class,0); 11834 } 11835 public ParamTagContext paramTag() { 11836 return getRuleContext(ParamTagContext.class,0); 11837 } 11838 public WrongSinletonTagContext wrongSinletonTag() { 11839 return getRuleContext(WrongSinletonTagContext.class,0); 11840 } 11841 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11842 super(parent, invokingState); 11843 } 11844 @Override public int getRuleIndex() { return RULE_singletonElement; } 11845 @Override 11846 public void enterRule(ParseTreeListener listener) { 11847 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11848 } 11849 @Override 11850 public void exitRule(ParseTreeListener listener) { 11851 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11852 } 11853 @Override 11854 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11855 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11856 else return visitor.visitChildren(this); 11857 } 11858 } 11859 11860 public final SingletonElementContext singletonElement() throws RecognitionException { 11861 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11862 enterRule(_localctx, 102, RULE_singletonElement); 11863 try { 11864 setState(1356); 11865 _errHandler.sync(this); 11866 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11867 case 1: 11868 enterOuterAlt(_localctx, 1); 11869 { 11870 setState(1341); 11871 singletonTag(); 11872 } 11873 break; 11874 case 2: 11875 enterOuterAlt(_localctx, 2); 11876 { 11877 setState(1342); 11878 areaTag(); 11879 } 11880 break; 11881 case 3: 11882 enterOuterAlt(_localctx, 3); 11883 { 11884 setState(1343); 11885 baseTag(); 11886 } 11887 break; 11888 case 4: 11889 enterOuterAlt(_localctx, 4); 11890 { 11891 setState(1344); 11892 basefontTag(); 11893 } 11894 break; 11895 case 5: 11896 enterOuterAlt(_localctx, 5); 11897 { 11898 setState(1345); 11899 brTag(); 11900 } 11901 break; 11902 case 6: 11903 enterOuterAlt(_localctx, 6); 11904 { 11905 setState(1346); 11906 colTag(); 11907 } 11908 break; 11909 case 7: 11910 enterOuterAlt(_localctx, 7); 11911 { 11912 setState(1347); 11913 frameTag(); 11914 } 11915 break; 11916 case 8: 11917 enterOuterAlt(_localctx, 8); 11918 { 11919 setState(1348); 11920 hrTag(); 11921 } 11922 break; 11923 case 9: 11924 enterOuterAlt(_localctx, 9); 11925 { 11926 setState(1349); 11927 imgTag(); 11928 } 11929 break; 11930 case 10: 11931 enterOuterAlt(_localctx, 10); 11932 { 11933 setState(1350); 11934 inputTag(); 11935 } 11936 break; 11937 case 11: 11938 enterOuterAlt(_localctx, 11); 11939 { 11940 setState(1351); 11941 isindexTag(); 11942 } 11943 break; 11944 case 12: 11945 enterOuterAlt(_localctx, 12); 11946 { 11947 setState(1352); 11948 linkTag(); 11949 } 11950 break; 11951 case 13: 11952 enterOuterAlt(_localctx, 13); 11953 { 11954 setState(1353); 11955 metaTag(); 11956 } 11957 break; 11958 case 14: 11959 enterOuterAlt(_localctx, 14); 11960 { 11961 setState(1354); 11962 paramTag(); 11963 } 11964 break; 11965 case 15: 11966 enterOuterAlt(_localctx, 15); 11967 { 11968 setState(1355); 11969 wrongSinletonTag(); 11970 } 11971 break; 11972 } 11973 } 11974 catch (RecognitionException re) { 11975 _localctx.exception = re; 11976 _errHandler.reportError(this, re); 11977 _errHandler.recover(this, re); 11978 } 11979 finally { 11980 exitRule(); 11981 } 11982 return _localctx; 11983 } 11984 11985 public static class SingletonTagContext extends ParserRuleContext { 11986 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11987 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11988 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11989 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11990 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11991 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11992 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11993 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11994 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11995 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11996 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11997 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11998 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11999 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 12000 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 12001 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 12002 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 12003 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12004 public List<AttributeContext> attribute() { 12005 return getRuleContexts(AttributeContext.class); 12006 } 12007 public AttributeContext attribute(int i) { 12008 return getRuleContext(AttributeContext.class,i); 12009 } 12010 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12011 public TerminalNode NEWLINE(int i) { 12012 return getToken(JavadocParser.NEWLINE, i); 12013 } 12014 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12015 public TerminalNode LEADING_ASTERISK(int i) { 12016 return getToken(JavadocParser.LEADING_ASTERISK, i); 12017 } 12018 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12019 public TerminalNode WS(int i) { 12020 return getToken(JavadocParser.WS, i); 12021 } 12022 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 12023 super(parent, invokingState); 12024 } 12025 @Override public int getRuleIndex() { return RULE_singletonTag; } 12026 @Override 12027 public void enterRule(ParseTreeListener listener) { 12028 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 12029 } 12030 @Override 12031 public void exitRule(ParseTreeListener listener) { 12032 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 12033 } 12034 @Override 12035 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12036 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 12037 else return visitor.visitChildren(this); 12038 } 12039 } 12040 12041 public final SingletonTagContext singletonTag() throws RecognitionException { 12042 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 12043 enterRule(_localctx, 104, RULE_singletonTag); 12044 int _la; 12045 try { 12046 enterOuterAlt(_localctx, 1); 12047 { 12048 setState(1358); 12049 match(OPEN); 12050 setState(1359); 12051 _la = _input.LA(1); 12052 if ( !(((((_la - 59)) & ~0x3f) == 0 && ((1L << (_la - 59)) & ((1L << (P_HTML_TAG_NAME - 59)) | (1L << (LI_HTML_TAG_NAME - 59)) | (1L << (TR_HTML_TAG_NAME - 59)) | (1L << (TD_HTML_TAG_NAME - 59)) | (1L << (TH_HTML_TAG_NAME - 59)) | (1L << (BODY_HTML_TAG_NAME - 59)) | (1L << (COLGROUP_HTML_TAG_NAME - 59)) | (1L << (DD_HTML_TAG_NAME - 59)) | (1L << (DT_HTML_TAG_NAME - 59)) | (1L << (HEAD_HTML_TAG_NAME - 59)) | (1L << (HTML_HTML_TAG_NAME - 59)) | (1L << (OPTION_HTML_TAG_NAME - 59)) | (1L << (TBODY_HTML_TAG_NAME - 59)) | (1L << (TFOOT_HTML_TAG_NAME - 59)) | (1L << (THEAD_HTML_TAG_NAME - 59)) | (1L << (HTML_TAG_NAME - 59)))) != 0)) ) { 12053 _errHandler.recoverInline(this); 12054 } 12055 else { 12056 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12057 _errHandler.reportMatch(this); 12058 consume(); 12059 } 12060 setState(1366); 12061 _errHandler.sync(this); 12062 _la = _input.LA(1); 12063 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12064 { 12065 setState(1364); 12066 _errHandler.sync(this); 12067 switch (_input.LA(1)) { 12068 case HTML_TAG_NAME: 12069 { 12070 setState(1360); 12071 attribute(); 12072 } 12073 break; 12074 case NEWLINE: 12075 { 12076 setState(1361); 12077 match(NEWLINE); 12078 } 12079 break; 12080 case LEADING_ASTERISK: 12081 { 12082 setState(1362); 12083 match(LEADING_ASTERISK); 12084 } 12085 break; 12086 case WS: 12087 { 12088 setState(1363); 12089 match(WS); 12090 } 12091 break; 12092 default: 12093 throw new NoViableAltException(this); 12094 } 12095 } 12096 setState(1368); 12097 _errHandler.sync(this); 12098 _la = _input.LA(1); 12099 } 12100 setState(1369); 12101 match(SLASH_CLOSE); 12102 } 12103 } 12104 catch (RecognitionException re) { 12105 _localctx.exception = re; 12106 _errHandler.reportError(this, re); 12107 _errHandler.recover(this, re); 12108 } 12109 finally { 12110 exitRule(); 12111 } 12112 return _localctx; 12113 } 12114 12115 public static class AreaTagContext extends ParserRuleContext { 12116 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12117 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12118 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12119 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12120 public List<AttributeContext> attribute() { 12121 return getRuleContexts(AttributeContext.class); 12122 } 12123 public AttributeContext attribute(int i) { 12124 return getRuleContext(AttributeContext.class,i); 12125 } 12126 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12127 public TerminalNode NEWLINE(int i) { 12128 return getToken(JavadocParser.NEWLINE, i); 12129 } 12130 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12131 public TerminalNode LEADING_ASTERISK(int i) { 12132 return getToken(JavadocParser.LEADING_ASTERISK, i); 12133 } 12134 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12135 public TerminalNode WS(int i) { 12136 return getToken(JavadocParser.WS, i); 12137 } 12138 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12139 super(parent, invokingState); 12140 } 12141 @Override public int getRuleIndex() { return RULE_areaTag; } 12142 @Override 12143 public void enterRule(ParseTreeListener listener) { 12144 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12145 } 12146 @Override 12147 public void exitRule(ParseTreeListener listener) { 12148 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12149 } 12150 @Override 12151 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12152 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12153 else return visitor.visitChildren(this); 12154 } 12155 } 12156 12157 public final AreaTagContext areaTag() throws RecognitionException { 12158 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12159 enterRule(_localctx, 106, RULE_areaTag); 12160 int _la; 12161 try { 12162 enterOuterAlt(_localctx, 1); 12163 { 12164 setState(1371); 12165 match(OPEN); 12166 setState(1372); 12167 match(AREA_HTML_TAG_NAME); 12168 setState(1379); 12169 _errHandler.sync(this); 12170 _la = _input.LA(1); 12171 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12172 { 12173 setState(1377); 12174 _errHandler.sync(this); 12175 switch (_input.LA(1)) { 12176 case HTML_TAG_NAME: 12177 { 12178 setState(1373); 12179 attribute(); 12180 } 12181 break; 12182 case NEWLINE: 12183 { 12184 setState(1374); 12185 match(NEWLINE); 12186 } 12187 break; 12188 case LEADING_ASTERISK: 12189 { 12190 setState(1375); 12191 match(LEADING_ASTERISK); 12192 } 12193 break; 12194 case WS: 12195 { 12196 setState(1376); 12197 match(WS); 12198 } 12199 break; 12200 default: 12201 throw new NoViableAltException(this); 12202 } 12203 } 12204 setState(1381); 12205 _errHandler.sync(this); 12206 _la = _input.LA(1); 12207 } 12208 setState(1382); 12209 _la = _input.LA(1); 12210 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12211 _errHandler.recoverInline(this); 12212 } 12213 else { 12214 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12215 _errHandler.reportMatch(this); 12216 consume(); 12217 } 12218 } 12219 } 12220 catch (RecognitionException re) { 12221 _localctx.exception = re; 12222 _errHandler.reportError(this, re); 12223 _errHandler.recover(this, re); 12224 } 12225 finally { 12226 exitRule(); 12227 } 12228 return _localctx; 12229 } 12230 12231 public static class BaseTagContext extends ParserRuleContext { 12232 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12233 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12234 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12235 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12236 public List<AttributeContext> attribute() { 12237 return getRuleContexts(AttributeContext.class); 12238 } 12239 public AttributeContext attribute(int i) { 12240 return getRuleContext(AttributeContext.class,i); 12241 } 12242 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12243 public TerminalNode NEWLINE(int i) { 12244 return getToken(JavadocParser.NEWLINE, i); 12245 } 12246 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12247 public TerminalNode LEADING_ASTERISK(int i) { 12248 return getToken(JavadocParser.LEADING_ASTERISK, i); 12249 } 12250 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12251 public TerminalNode WS(int i) { 12252 return getToken(JavadocParser.WS, i); 12253 } 12254 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12255 super(parent, invokingState); 12256 } 12257 @Override public int getRuleIndex() { return RULE_baseTag; } 12258 @Override 12259 public void enterRule(ParseTreeListener listener) { 12260 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12261 } 12262 @Override 12263 public void exitRule(ParseTreeListener listener) { 12264 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12265 } 12266 @Override 12267 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12268 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12269 else return visitor.visitChildren(this); 12270 } 12271 } 12272 12273 public final BaseTagContext baseTag() throws RecognitionException { 12274 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12275 enterRule(_localctx, 108, RULE_baseTag); 12276 int _la; 12277 try { 12278 enterOuterAlt(_localctx, 1); 12279 { 12280 setState(1384); 12281 match(OPEN); 12282 setState(1385); 12283 match(BASE_HTML_TAG_NAME); 12284 setState(1392); 12285 _errHandler.sync(this); 12286 _la = _input.LA(1); 12287 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12288 { 12289 setState(1390); 12290 _errHandler.sync(this); 12291 switch (_input.LA(1)) { 12292 case HTML_TAG_NAME: 12293 { 12294 setState(1386); 12295 attribute(); 12296 } 12297 break; 12298 case NEWLINE: 12299 { 12300 setState(1387); 12301 match(NEWLINE); 12302 } 12303 break; 12304 case LEADING_ASTERISK: 12305 { 12306 setState(1388); 12307 match(LEADING_ASTERISK); 12308 } 12309 break; 12310 case WS: 12311 { 12312 setState(1389); 12313 match(WS); 12314 } 12315 break; 12316 default: 12317 throw new NoViableAltException(this); 12318 } 12319 } 12320 setState(1394); 12321 _errHandler.sync(this); 12322 _la = _input.LA(1); 12323 } 12324 setState(1395); 12325 _la = _input.LA(1); 12326 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12327 _errHandler.recoverInline(this); 12328 } 12329 else { 12330 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12331 _errHandler.reportMatch(this); 12332 consume(); 12333 } 12334 } 12335 } 12336 catch (RecognitionException re) { 12337 _localctx.exception = re; 12338 _errHandler.reportError(this, re); 12339 _errHandler.recover(this, re); 12340 } 12341 finally { 12342 exitRule(); 12343 } 12344 return _localctx; 12345 } 12346 12347 public static class BasefontTagContext extends ParserRuleContext { 12348 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12349 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 12350 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12351 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12352 public List<AttributeContext> attribute() { 12353 return getRuleContexts(AttributeContext.class); 12354 } 12355 public AttributeContext attribute(int i) { 12356 return getRuleContext(AttributeContext.class,i); 12357 } 12358 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12359 public TerminalNode NEWLINE(int i) { 12360 return getToken(JavadocParser.NEWLINE, i); 12361 } 12362 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12363 public TerminalNode LEADING_ASTERISK(int i) { 12364 return getToken(JavadocParser.LEADING_ASTERISK, i); 12365 } 12366 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12367 public TerminalNode WS(int i) { 12368 return getToken(JavadocParser.WS, i); 12369 } 12370 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 12371 super(parent, invokingState); 12372 } 12373 @Override public int getRuleIndex() { return RULE_basefontTag; } 12374 @Override 12375 public void enterRule(ParseTreeListener listener) { 12376 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this); 12377 } 12378 @Override 12379 public void exitRule(ParseTreeListener listener) { 12380 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this); 12381 } 12382 @Override 12383 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12384 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this); 12385 else return visitor.visitChildren(this); 12386 } 12387 } 12388 12389 public final BasefontTagContext basefontTag() throws RecognitionException { 12390 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 12391 enterRule(_localctx, 110, RULE_basefontTag); 12392 int _la; 12393 try { 12394 enterOuterAlt(_localctx, 1); 12395 { 12396 setState(1397); 12397 match(OPEN); 12398 setState(1398); 12399 match(BASEFONT_HTML_TAG_NAME); 12400 setState(1405); 12401 _errHandler.sync(this); 12402 _la = _input.LA(1); 12403 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12404 { 12405 setState(1403); 12406 _errHandler.sync(this); 12407 switch (_input.LA(1)) { 12408 case HTML_TAG_NAME: 12409 { 12410 setState(1399); 12411 attribute(); 12412 } 12413 break; 12414 case NEWLINE: 12415 { 12416 setState(1400); 12417 match(NEWLINE); 12418 } 12419 break; 12420 case LEADING_ASTERISK: 12421 { 12422 setState(1401); 12423 match(LEADING_ASTERISK); 12424 } 12425 break; 12426 case WS: 12427 { 12428 setState(1402); 12429 match(WS); 12430 } 12431 break; 12432 default: 12433 throw new NoViableAltException(this); 12434 } 12435 } 12436 setState(1407); 12437 _errHandler.sync(this); 12438 _la = _input.LA(1); 12439 } 12440 setState(1408); 12441 _la = _input.LA(1); 12442 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12443 _errHandler.recoverInline(this); 12444 } 12445 else { 12446 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12447 _errHandler.reportMatch(this); 12448 consume(); 12449 } 12450 } 12451 } 12452 catch (RecognitionException re) { 12453 _localctx.exception = re; 12454 _errHandler.reportError(this, re); 12455 _errHandler.recover(this, re); 12456 } 12457 finally { 12458 exitRule(); 12459 } 12460 return _localctx; 12461 } 12462 12463 public static class BrTagContext extends ParserRuleContext { 12464 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12465 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12466 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12467 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12468 public List<AttributeContext> attribute() { 12469 return getRuleContexts(AttributeContext.class); 12470 } 12471 public AttributeContext attribute(int i) { 12472 return getRuleContext(AttributeContext.class,i); 12473 } 12474 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12475 public TerminalNode NEWLINE(int i) { 12476 return getToken(JavadocParser.NEWLINE, i); 12477 } 12478 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12479 public TerminalNode LEADING_ASTERISK(int i) { 12480 return getToken(JavadocParser.LEADING_ASTERISK, i); 12481 } 12482 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12483 public TerminalNode WS(int i) { 12484 return getToken(JavadocParser.WS, i); 12485 } 12486 public BrTagContext(ParserRuleContext parent, int invokingState) { 12487 super(parent, invokingState); 12488 } 12489 @Override public int getRuleIndex() { return RULE_brTag; } 12490 @Override 12491 public void enterRule(ParseTreeListener listener) { 12492 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12493 } 12494 @Override 12495 public void exitRule(ParseTreeListener listener) { 12496 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12497 } 12498 @Override 12499 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12500 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12501 else return visitor.visitChildren(this); 12502 } 12503 } 12504 12505 public final BrTagContext brTag() throws RecognitionException { 12506 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12507 enterRule(_localctx, 112, RULE_brTag); 12508 int _la; 12509 try { 12510 enterOuterAlt(_localctx, 1); 12511 { 12512 setState(1410); 12513 match(OPEN); 12514 setState(1411); 12515 match(BR_HTML_TAG_NAME); 12516 setState(1418); 12517 _errHandler.sync(this); 12518 _la = _input.LA(1); 12519 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12520 { 12521 setState(1416); 12522 _errHandler.sync(this); 12523 switch (_input.LA(1)) { 12524 case HTML_TAG_NAME: 12525 { 12526 setState(1412); 12527 attribute(); 12528 } 12529 break; 12530 case NEWLINE: 12531 { 12532 setState(1413); 12533 match(NEWLINE); 12534 } 12535 break; 12536 case LEADING_ASTERISK: 12537 { 12538 setState(1414); 12539 match(LEADING_ASTERISK); 12540 } 12541 break; 12542 case WS: 12543 { 12544 setState(1415); 12545 match(WS); 12546 } 12547 break; 12548 default: 12549 throw new NoViableAltException(this); 12550 } 12551 } 12552 setState(1420); 12553 _errHandler.sync(this); 12554 _la = _input.LA(1); 12555 } 12556 setState(1421); 12557 _la = _input.LA(1); 12558 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12559 _errHandler.recoverInline(this); 12560 } 12561 else { 12562 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12563 _errHandler.reportMatch(this); 12564 consume(); 12565 } 12566 } 12567 } 12568 catch (RecognitionException re) { 12569 _localctx.exception = re; 12570 _errHandler.reportError(this, re); 12571 _errHandler.recover(this, re); 12572 } 12573 finally { 12574 exitRule(); 12575 } 12576 return _localctx; 12577 } 12578 12579 public static class ColTagContext extends ParserRuleContext { 12580 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12581 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12582 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12583 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12584 public List<AttributeContext> attribute() { 12585 return getRuleContexts(AttributeContext.class); 12586 } 12587 public AttributeContext attribute(int i) { 12588 return getRuleContext(AttributeContext.class,i); 12589 } 12590 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12591 public TerminalNode NEWLINE(int i) { 12592 return getToken(JavadocParser.NEWLINE, i); 12593 } 12594 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12595 public TerminalNode LEADING_ASTERISK(int i) { 12596 return getToken(JavadocParser.LEADING_ASTERISK, i); 12597 } 12598 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12599 public TerminalNode WS(int i) { 12600 return getToken(JavadocParser.WS, i); 12601 } 12602 public ColTagContext(ParserRuleContext parent, int invokingState) { 12603 super(parent, invokingState); 12604 } 12605 @Override public int getRuleIndex() { return RULE_colTag; } 12606 @Override 12607 public void enterRule(ParseTreeListener listener) { 12608 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12609 } 12610 @Override 12611 public void exitRule(ParseTreeListener listener) { 12612 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12613 } 12614 @Override 12615 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12616 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12617 else return visitor.visitChildren(this); 12618 } 12619 } 12620 12621 public final ColTagContext colTag() throws RecognitionException { 12622 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12623 enterRule(_localctx, 114, RULE_colTag); 12624 int _la; 12625 try { 12626 enterOuterAlt(_localctx, 1); 12627 { 12628 setState(1423); 12629 match(OPEN); 12630 setState(1424); 12631 match(COL_HTML_TAG_NAME); 12632 setState(1431); 12633 _errHandler.sync(this); 12634 _la = _input.LA(1); 12635 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12636 { 12637 setState(1429); 12638 _errHandler.sync(this); 12639 switch (_input.LA(1)) { 12640 case HTML_TAG_NAME: 12641 { 12642 setState(1425); 12643 attribute(); 12644 } 12645 break; 12646 case NEWLINE: 12647 { 12648 setState(1426); 12649 match(NEWLINE); 12650 } 12651 break; 12652 case LEADING_ASTERISK: 12653 { 12654 setState(1427); 12655 match(LEADING_ASTERISK); 12656 } 12657 break; 12658 case WS: 12659 { 12660 setState(1428); 12661 match(WS); 12662 } 12663 break; 12664 default: 12665 throw new NoViableAltException(this); 12666 } 12667 } 12668 setState(1433); 12669 _errHandler.sync(this); 12670 _la = _input.LA(1); 12671 } 12672 setState(1434); 12673 _la = _input.LA(1); 12674 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12675 _errHandler.recoverInline(this); 12676 } 12677 else { 12678 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12679 _errHandler.reportMatch(this); 12680 consume(); 12681 } 12682 } 12683 } 12684 catch (RecognitionException re) { 12685 _localctx.exception = re; 12686 _errHandler.reportError(this, re); 12687 _errHandler.recover(this, re); 12688 } 12689 finally { 12690 exitRule(); 12691 } 12692 return _localctx; 12693 } 12694 12695 public static class FrameTagContext extends ParserRuleContext { 12696 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12697 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12698 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12699 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12700 public List<AttributeContext> attribute() { 12701 return getRuleContexts(AttributeContext.class); 12702 } 12703 public AttributeContext attribute(int i) { 12704 return getRuleContext(AttributeContext.class,i); 12705 } 12706 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12707 public TerminalNode NEWLINE(int i) { 12708 return getToken(JavadocParser.NEWLINE, i); 12709 } 12710 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12711 public TerminalNode LEADING_ASTERISK(int i) { 12712 return getToken(JavadocParser.LEADING_ASTERISK, i); 12713 } 12714 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12715 public TerminalNode WS(int i) { 12716 return getToken(JavadocParser.WS, i); 12717 } 12718 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12719 super(parent, invokingState); 12720 } 12721 @Override public int getRuleIndex() { return RULE_frameTag; } 12722 @Override 12723 public void enterRule(ParseTreeListener listener) { 12724 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12725 } 12726 @Override 12727 public void exitRule(ParseTreeListener listener) { 12728 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12729 } 12730 @Override 12731 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12732 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12733 else return visitor.visitChildren(this); 12734 } 12735 } 12736 12737 public final FrameTagContext frameTag() throws RecognitionException { 12738 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12739 enterRule(_localctx, 116, RULE_frameTag); 12740 int _la; 12741 try { 12742 enterOuterAlt(_localctx, 1); 12743 { 12744 setState(1436); 12745 match(OPEN); 12746 setState(1437); 12747 match(FRAME_HTML_TAG_NAME); 12748 setState(1444); 12749 _errHandler.sync(this); 12750 _la = _input.LA(1); 12751 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12752 { 12753 setState(1442); 12754 _errHandler.sync(this); 12755 switch (_input.LA(1)) { 12756 case HTML_TAG_NAME: 12757 { 12758 setState(1438); 12759 attribute(); 12760 } 12761 break; 12762 case NEWLINE: 12763 { 12764 setState(1439); 12765 match(NEWLINE); 12766 } 12767 break; 12768 case LEADING_ASTERISK: 12769 { 12770 setState(1440); 12771 match(LEADING_ASTERISK); 12772 } 12773 break; 12774 case WS: 12775 { 12776 setState(1441); 12777 match(WS); 12778 } 12779 break; 12780 default: 12781 throw new NoViableAltException(this); 12782 } 12783 } 12784 setState(1446); 12785 _errHandler.sync(this); 12786 _la = _input.LA(1); 12787 } 12788 setState(1447); 12789 _la = _input.LA(1); 12790 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12791 _errHandler.recoverInline(this); 12792 } 12793 else { 12794 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12795 _errHandler.reportMatch(this); 12796 consume(); 12797 } 12798 } 12799 } 12800 catch (RecognitionException re) { 12801 _localctx.exception = re; 12802 _errHandler.reportError(this, re); 12803 _errHandler.recover(this, re); 12804 } 12805 finally { 12806 exitRule(); 12807 } 12808 return _localctx; 12809 } 12810 12811 public static class HrTagContext extends ParserRuleContext { 12812 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12813 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12814 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12815 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12816 public List<AttributeContext> attribute() { 12817 return getRuleContexts(AttributeContext.class); 12818 } 12819 public AttributeContext attribute(int i) { 12820 return getRuleContext(AttributeContext.class,i); 12821 } 12822 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12823 public TerminalNode NEWLINE(int i) { 12824 return getToken(JavadocParser.NEWLINE, i); 12825 } 12826 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12827 public TerminalNode LEADING_ASTERISK(int i) { 12828 return getToken(JavadocParser.LEADING_ASTERISK, i); 12829 } 12830 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12831 public TerminalNode WS(int i) { 12832 return getToken(JavadocParser.WS, i); 12833 } 12834 public HrTagContext(ParserRuleContext parent, int invokingState) { 12835 super(parent, invokingState); 12836 } 12837 @Override public int getRuleIndex() { return RULE_hrTag; } 12838 @Override 12839 public void enterRule(ParseTreeListener listener) { 12840 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12841 } 12842 @Override 12843 public void exitRule(ParseTreeListener listener) { 12844 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12845 } 12846 @Override 12847 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12848 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12849 else return visitor.visitChildren(this); 12850 } 12851 } 12852 12853 public final HrTagContext hrTag() throws RecognitionException { 12854 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12855 enterRule(_localctx, 118, RULE_hrTag); 12856 int _la; 12857 try { 12858 enterOuterAlt(_localctx, 1); 12859 { 12860 setState(1449); 12861 match(OPEN); 12862 setState(1450); 12863 match(HR_HTML_TAG_NAME); 12864 setState(1457); 12865 _errHandler.sync(this); 12866 _la = _input.LA(1); 12867 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12868 { 12869 setState(1455); 12870 _errHandler.sync(this); 12871 switch (_input.LA(1)) { 12872 case HTML_TAG_NAME: 12873 { 12874 setState(1451); 12875 attribute(); 12876 } 12877 break; 12878 case NEWLINE: 12879 { 12880 setState(1452); 12881 match(NEWLINE); 12882 } 12883 break; 12884 case LEADING_ASTERISK: 12885 { 12886 setState(1453); 12887 match(LEADING_ASTERISK); 12888 } 12889 break; 12890 case WS: 12891 { 12892 setState(1454); 12893 match(WS); 12894 } 12895 break; 12896 default: 12897 throw new NoViableAltException(this); 12898 } 12899 } 12900 setState(1459); 12901 _errHandler.sync(this); 12902 _la = _input.LA(1); 12903 } 12904 setState(1460); 12905 _la = _input.LA(1); 12906 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12907 _errHandler.recoverInline(this); 12908 } 12909 else { 12910 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12911 _errHandler.reportMatch(this); 12912 consume(); 12913 } 12914 } 12915 } 12916 catch (RecognitionException re) { 12917 _localctx.exception = re; 12918 _errHandler.reportError(this, re); 12919 _errHandler.recover(this, re); 12920 } 12921 finally { 12922 exitRule(); 12923 } 12924 return _localctx; 12925 } 12926 12927 public static class ImgTagContext extends ParserRuleContext { 12928 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12929 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12930 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12931 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12932 public List<AttributeContext> attribute() { 12933 return getRuleContexts(AttributeContext.class); 12934 } 12935 public AttributeContext attribute(int i) { 12936 return getRuleContext(AttributeContext.class,i); 12937 } 12938 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12939 public TerminalNode NEWLINE(int i) { 12940 return getToken(JavadocParser.NEWLINE, i); 12941 } 12942 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12943 public TerminalNode LEADING_ASTERISK(int i) { 12944 return getToken(JavadocParser.LEADING_ASTERISK, i); 12945 } 12946 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12947 public TerminalNode WS(int i) { 12948 return getToken(JavadocParser.WS, i); 12949 } 12950 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12951 super(parent, invokingState); 12952 } 12953 @Override public int getRuleIndex() { return RULE_imgTag; } 12954 @Override 12955 public void enterRule(ParseTreeListener listener) { 12956 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12957 } 12958 @Override 12959 public void exitRule(ParseTreeListener listener) { 12960 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12961 } 12962 @Override 12963 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12964 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12965 else return visitor.visitChildren(this); 12966 } 12967 } 12968 12969 public final ImgTagContext imgTag() throws RecognitionException { 12970 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12971 enterRule(_localctx, 120, RULE_imgTag); 12972 int _la; 12973 try { 12974 enterOuterAlt(_localctx, 1); 12975 { 12976 setState(1462); 12977 match(OPEN); 12978 setState(1463); 12979 match(IMG_HTML_TAG_NAME); 12980 setState(1470); 12981 _errHandler.sync(this); 12982 _la = _input.LA(1); 12983 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12984 { 12985 setState(1468); 12986 _errHandler.sync(this); 12987 switch (_input.LA(1)) { 12988 case HTML_TAG_NAME: 12989 { 12990 setState(1464); 12991 attribute(); 12992 } 12993 break; 12994 case NEWLINE: 12995 { 12996 setState(1465); 12997 match(NEWLINE); 12998 } 12999 break; 13000 case LEADING_ASTERISK: 13001 { 13002 setState(1466); 13003 match(LEADING_ASTERISK); 13004 } 13005 break; 13006 case WS: 13007 { 13008 setState(1467); 13009 match(WS); 13010 } 13011 break; 13012 default: 13013 throw new NoViableAltException(this); 13014 } 13015 } 13016 setState(1472); 13017 _errHandler.sync(this); 13018 _la = _input.LA(1); 13019 } 13020 setState(1473); 13021 _la = _input.LA(1); 13022 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13023 _errHandler.recoverInline(this); 13024 } 13025 else { 13026 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13027 _errHandler.reportMatch(this); 13028 consume(); 13029 } 13030 } 13031 } 13032 catch (RecognitionException re) { 13033 _localctx.exception = re; 13034 _errHandler.reportError(this, re); 13035 _errHandler.recover(this, re); 13036 } 13037 finally { 13038 exitRule(); 13039 } 13040 return _localctx; 13041 } 13042 13043 public static class InputTagContext extends ParserRuleContext { 13044 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13045 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13046 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13047 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13048 public List<AttributeContext> attribute() { 13049 return getRuleContexts(AttributeContext.class); 13050 } 13051 public AttributeContext attribute(int i) { 13052 return getRuleContext(AttributeContext.class,i); 13053 } 13054 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13055 public TerminalNode NEWLINE(int i) { 13056 return getToken(JavadocParser.NEWLINE, i); 13057 } 13058 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13059 public TerminalNode LEADING_ASTERISK(int i) { 13060 return getToken(JavadocParser.LEADING_ASTERISK, i); 13061 } 13062 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13063 public TerminalNode WS(int i) { 13064 return getToken(JavadocParser.WS, i); 13065 } 13066 public InputTagContext(ParserRuleContext parent, int invokingState) { 13067 super(parent, invokingState); 13068 } 13069 @Override public int getRuleIndex() { return RULE_inputTag; } 13070 @Override 13071 public void enterRule(ParseTreeListener listener) { 13072 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 13073 } 13074 @Override 13075 public void exitRule(ParseTreeListener listener) { 13076 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 13077 } 13078 @Override 13079 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13080 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 13081 else return visitor.visitChildren(this); 13082 } 13083 } 13084 13085 public final InputTagContext inputTag() throws RecognitionException { 13086 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 13087 enterRule(_localctx, 122, RULE_inputTag); 13088 int _la; 13089 try { 13090 enterOuterAlt(_localctx, 1); 13091 { 13092 setState(1475); 13093 match(OPEN); 13094 setState(1476); 13095 match(INPUT_HTML_TAG_NAME); 13096 setState(1483); 13097 _errHandler.sync(this); 13098 _la = _input.LA(1); 13099 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13100 { 13101 setState(1481); 13102 _errHandler.sync(this); 13103 switch (_input.LA(1)) { 13104 case HTML_TAG_NAME: 13105 { 13106 setState(1477); 13107 attribute(); 13108 } 13109 break; 13110 case NEWLINE: 13111 { 13112 setState(1478); 13113 match(NEWLINE); 13114 } 13115 break; 13116 case LEADING_ASTERISK: 13117 { 13118 setState(1479); 13119 match(LEADING_ASTERISK); 13120 } 13121 break; 13122 case WS: 13123 { 13124 setState(1480); 13125 match(WS); 13126 } 13127 break; 13128 default: 13129 throw new NoViableAltException(this); 13130 } 13131 } 13132 setState(1485); 13133 _errHandler.sync(this); 13134 _la = _input.LA(1); 13135 } 13136 setState(1486); 13137 _la = _input.LA(1); 13138 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13139 _errHandler.recoverInline(this); 13140 } 13141 else { 13142 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13143 _errHandler.reportMatch(this); 13144 consume(); 13145 } 13146 } 13147 } 13148 catch (RecognitionException re) { 13149 _localctx.exception = re; 13150 _errHandler.reportError(this, re); 13151 _errHandler.recover(this, re); 13152 } 13153 finally { 13154 exitRule(); 13155 } 13156 return _localctx; 13157 } 13158 13159 public static class IsindexTagContext extends ParserRuleContext { 13160 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13161 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13162 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13163 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13164 public List<AttributeContext> attribute() { 13165 return getRuleContexts(AttributeContext.class); 13166 } 13167 public AttributeContext attribute(int i) { 13168 return getRuleContext(AttributeContext.class,i); 13169 } 13170 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13171 public TerminalNode NEWLINE(int i) { 13172 return getToken(JavadocParser.NEWLINE, i); 13173 } 13174 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13175 public TerminalNode LEADING_ASTERISK(int i) { 13176 return getToken(JavadocParser.LEADING_ASTERISK, i); 13177 } 13178 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13179 public TerminalNode WS(int i) { 13180 return getToken(JavadocParser.WS, i); 13181 } 13182 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13183 super(parent, invokingState); 13184 } 13185 @Override public int getRuleIndex() { return RULE_isindexTag; } 13186 @Override 13187 public void enterRule(ParseTreeListener listener) { 13188 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13189 } 13190 @Override 13191 public void exitRule(ParseTreeListener listener) { 13192 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13193 } 13194 @Override 13195 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13196 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13197 else return visitor.visitChildren(this); 13198 } 13199 } 13200 13201 public final IsindexTagContext isindexTag() throws RecognitionException { 13202 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13203 enterRule(_localctx, 124, RULE_isindexTag); 13204 int _la; 13205 try { 13206 enterOuterAlt(_localctx, 1); 13207 { 13208 setState(1488); 13209 match(OPEN); 13210 setState(1489); 13211 match(ISINDEX_HTML_TAG_NAME); 13212 setState(1496); 13213 _errHandler.sync(this); 13214 _la = _input.LA(1); 13215 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13216 { 13217 setState(1494); 13218 _errHandler.sync(this); 13219 switch (_input.LA(1)) { 13220 case HTML_TAG_NAME: 13221 { 13222 setState(1490); 13223 attribute(); 13224 } 13225 break; 13226 case NEWLINE: 13227 { 13228 setState(1491); 13229 match(NEWLINE); 13230 } 13231 break; 13232 case LEADING_ASTERISK: 13233 { 13234 setState(1492); 13235 match(LEADING_ASTERISK); 13236 } 13237 break; 13238 case WS: 13239 { 13240 setState(1493); 13241 match(WS); 13242 } 13243 break; 13244 default: 13245 throw new NoViableAltException(this); 13246 } 13247 } 13248 setState(1498); 13249 _errHandler.sync(this); 13250 _la = _input.LA(1); 13251 } 13252 setState(1499); 13253 _la = _input.LA(1); 13254 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13255 _errHandler.recoverInline(this); 13256 } 13257 else { 13258 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13259 _errHandler.reportMatch(this); 13260 consume(); 13261 } 13262 } 13263 } 13264 catch (RecognitionException re) { 13265 _localctx.exception = re; 13266 _errHandler.reportError(this, re); 13267 _errHandler.recover(this, re); 13268 } 13269 finally { 13270 exitRule(); 13271 } 13272 return _localctx; 13273 } 13274 13275 public static class LinkTagContext extends ParserRuleContext { 13276 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13277 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13278 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13279 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13280 public List<AttributeContext> attribute() { 13281 return getRuleContexts(AttributeContext.class); 13282 } 13283 public AttributeContext attribute(int i) { 13284 return getRuleContext(AttributeContext.class,i); 13285 } 13286 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13287 public TerminalNode NEWLINE(int i) { 13288 return getToken(JavadocParser.NEWLINE, i); 13289 } 13290 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13291 public TerminalNode LEADING_ASTERISK(int i) { 13292 return getToken(JavadocParser.LEADING_ASTERISK, i); 13293 } 13294 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13295 public TerminalNode WS(int i) { 13296 return getToken(JavadocParser.WS, i); 13297 } 13298 public LinkTagContext(ParserRuleContext parent, int invokingState) { 13299 super(parent, invokingState); 13300 } 13301 @Override public int getRuleIndex() { return RULE_linkTag; } 13302 @Override 13303 public void enterRule(ParseTreeListener listener) { 13304 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13305 } 13306 @Override 13307 public void exitRule(ParseTreeListener listener) { 13308 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13309 } 13310 @Override 13311 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13312 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13313 else return visitor.visitChildren(this); 13314 } 13315 } 13316 13317 public final LinkTagContext linkTag() throws RecognitionException { 13318 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13319 enterRule(_localctx, 126, RULE_linkTag); 13320 int _la; 13321 try { 13322 enterOuterAlt(_localctx, 1); 13323 { 13324 setState(1501); 13325 match(OPEN); 13326 setState(1502); 13327 match(LINK_HTML_TAG_NAME); 13328 setState(1509); 13329 _errHandler.sync(this); 13330 _la = _input.LA(1); 13331 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13332 { 13333 setState(1507); 13334 _errHandler.sync(this); 13335 switch (_input.LA(1)) { 13336 case HTML_TAG_NAME: 13337 { 13338 setState(1503); 13339 attribute(); 13340 } 13341 break; 13342 case NEWLINE: 13343 { 13344 setState(1504); 13345 match(NEWLINE); 13346 } 13347 break; 13348 case LEADING_ASTERISK: 13349 { 13350 setState(1505); 13351 match(LEADING_ASTERISK); 13352 } 13353 break; 13354 case WS: 13355 { 13356 setState(1506); 13357 match(WS); 13358 } 13359 break; 13360 default: 13361 throw new NoViableAltException(this); 13362 } 13363 } 13364 setState(1511); 13365 _errHandler.sync(this); 13366 _la = _input.LA(1); 13367 } 13368 setState(1512); 13369 _la = _input.LA(1); 13370 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13371 _errHandler.recoverInline(this); 13372 } 13373 else { 13374 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13375 _errHandler.reportMatch(this); 13376 consume(); 13377 } 13378 } 13379 } 13380 catch (RecognitionException re) { 13381 _localctx.exception = re; 13382 _errHandler.reportError(this, re); 13383 _errHandler.recover(this, re); 13384 } 13385 finally { 13386 exitRule(); 13387 } 13388 return _localctx; 13389 } 13390 13391 public static class MetaTagContext extends ParserRuleContext { 13392 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13393 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13394 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13395 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13396 public List<AttributeContext> attribute() { 13397 return getRuleContexts(AttributeContext.class); 13398 } 13399 public AttributeContext attribute(int i) { 13400 return getRuleContext(AttributeContext.class,i); 13401 } 13402 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13403 public TerminalNode NEWLINE(int i) { 13404 return getToken(JavadocParser.NEWLINE, i); 13405 } 13406 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13407 public TerminalNode LEADING_ASTERISK(int i) { 13408 return getToken(JavadocParser.LEADING_ASTERISK, i); 13409 } 13410 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13411 public TerminalNode WS(int i) { 13412 return getToken(JavadocParser.WS, i); 13413 } 13414 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13415 super(parent, invokingState); 13416 } 13417 @Override public int getRuleIndex() { return RULE_metaTag; } 13418 @Override 13419 public void enterRule(ParseTreeListener listener) { 13420 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13421 } 13422 @Override 13423 public void exitRule(ParseTreeListener listener) { 13424 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13425 } 13426 @Override 13427 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13428 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13429 else return visitor.visitChildren(this); 13430 } 13431 } 13432 13433 public final MetaTagContext metaTag() throws RecognitionException { 13434 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13435 enterRule(_localctx, 128, RULE_metaTag); 13436 int _la; 13437 try { 13438 enterOuterAlt(_localctx, 1); 13439 { 13440 setState(1514); 13441 match(OPEN); 13442 setState(1515); 13443 match(META_HTML_TAG_NAME); 13444 setState(1522); 13445 _errHandler.sync(this); 13446 _la = _input.LA(1); 13447 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13448 { 13449 setState(1520); 13450 _errHandler.sync(this); 13451 switch (_input.LA(1)) { 13452 case HTML_TAG_NAME: 13453 { 13454 setState(1516); 13455 attribute(); 13456 } 13457 break; 13458 case NEWLINE: 13459 { 13460 setState(1517); 13461 match(NEWLINE); 13462 } 13463 break; 13464 case LEADING_ASTERISK: 13465 { 13466 setState(1518); 13467 match(LEADING_ASTERISK); 13468 } 13469 break; 13470 case WS: 13471 { 13472 setState(1519); 13473 match(WS); 13474 } 13475 break; 13476 default: 13477 throw new NoViableAltException(this); 13478 } 13479 } 13480 setState(1524); 13481 _errHandler.sync(this); 13482 _la = _input.LA(1); 13483 } 13484 setState(1525); 13485 _la = _input.LA(1); 13486 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13487 _errHandler.recoverInline(this); 13488 } 13489 else { 13490 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13491 _errHandler.reportMatch(this); 13492 consume(); 13493 } 13494 } 13495 } 13496 catch (RecognitionException re) { 13497 _localctx.exception = re; 13498 _errHandler.reportError(this, re); 13499 _errHandler.recover(this, re); 13500 } 13501 finally { 13502 exitRule(); 13503 } 13504 return _localctx; 13505 } 13506 13507 public static class ParamTagContext extends ParserRuleContext { 13508 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13509 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13510 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13511 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13512 public List<AttributeContext> attribute() { 13513 return getRuleContexts(AttributeContext.class); 13514 } 13515 public AttributeContext attribute(int i) { 13516 return getRuleContext(AttributeContext.class,i); 13517 } 13518 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13519 public TerminalNode NEWLINE(int i) { 13520 return getToken(JavadocParser.NEWLINE, i); 13521 } 13522 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13523 public TerminalNode LEADING_ASTERISK(int i) { 13524 return getToken(JavadocParser.LEADING_ASTERISK, i); 13525 } 13526 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13527 public TerminalNode WS(int i) { 13528 return getToken(JavadocParser.WS, i); 13529 } 13530 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13531 super(parent, invokingState); 13532 } 13533 @Override public int getRuleIndex() { return RULE_paramTag; } 13534 @Override 13535 public void enterRule(ParseTreeListener listener) { 13536 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13537 } 13538 @Override 13539 public void exitRule(ParseTreeListener listener) { 13540 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13541 } 13542 @Override 13543 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13544 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13545 else return visitor.visitChildren(this); 13546 } 13547 } 13548 13549 public final ParamTagContext paramTag() throws RecognitionException { 13550 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13551 enterRule(_localctx, 130, RULE_paramTag); 13552 int _la; 13553 try { 13554 enterOuterAlt(_localctx, 1); 13555 { 13556 setState(1527); 13557 match(OPEN); 13558 setState(1528); 13559 match(PARAM_HTML_TAG_NAME); 13560 setState(1535); 13561 _errHandler.sync(this); 13562 _la = _input.LA(1); 13563 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13564 { 13565 setState(1533); 13566 _errHandler.sync(this); 13567 switch (_input.LA(1)) { 13568 case HTML_TAG_NAME: 13569 { 13570 setState(1529); 13571 attribute(); 13572 } 13573 break; 13574 case NEWLINE: 13575 { 13576 setState(1530); 13577 match(NEWLINE); 13578 } 13579 break; 13580 case LEADING_ASTERISK: 13581 { 13582 setState(1531); 13583 match(LEADING_ASTERISK); 13584 } 13585 break; 13586 case WS: 13587 { 13588 setState(1532); 13589 match(WS); 13590 } 13591 break; 13592 default: 13593 throw new NoViableAltException(this); 13594 } 13595 } 13596 setState(1537); 13597 _errHandler.sync(this); 13598 _la = _input.LA(1); 13599 } 13600 setState(1538); 13601 _la = _input.LA(1); 13602 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13603 _errHandler.recoverInline(this); 13604 } 13605 else { 13606 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13607 _errHandler.reportMatch(this); 13608 consume(); 13609 } 13610 } 13611 } 13612 catch (RecognitionException re) { 13613 _localctx.exception = re; 13614 _errHandler.reportError(this, re); 13615 _errHandler.recover(this, re); 13616 } 13617 finally { 13618 exitRule(); 13619 } 13620 return _localctx; 13621 } 13622 13623 public static class WrongSinletonTagContext extends ParserRuleContext { 13624 public SingletonTagNameContext singletonTagName; 13625 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13626 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13627 public SingletonTagNameContext singletonTagName() { 13628 return getRuleContext(SingletonTagNameContext.class,0); 13629 } 13630 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13631 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13632 super(parent, invokingState); 13633 } 13634 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13635 @Override 13636 public void enterRule(ParseTreeListener listener) { 13637 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13638 } 13639 @Override 13640 public void exitRule(ParseTreeListener listener) { 13641 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13642 } 13643 @Override 13644 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13645 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13646 else return visitor.visitChildren(this); 13647 } 13648 } 13649 13650 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13651 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13652 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13653 try { 13654 enterOuterAlt(_localctx, 1); 13655 { 13656 setState(1540); 13657 match(OPEN); 13658 setState(1541); 13659 match(SLASH); 13660 setState(1542); 13661 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13662 setState(1543); 13663 match(CLOSE); 13664 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), 13665 "javadoc.wrong.singleton.html.tag", null); 13666 } 13667 } 13668 catch (RecognitionException re) { 13669 _localctx.exception = re; 13670 _errHandler.reportError(this, re); 13671 _errHandler.recover(this, re); 13672 } 13673 finally { 13674 exitRule(); 13675 } 13676 return _localctx; 13677 } 13678 13679 public static class SingletonTagNameContext extends ParserRuleContext { 13680 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13681 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13682 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13683 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13684 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13685 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13686 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13687 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13688 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13689 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13690 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13691 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13692 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13693 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13694 super(parent, invokingState); 13695 } 13696 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13697 @Override 13698 public void enterRule(ParseTreeListener listener) { 13699 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13700 } 13701 @Override 13702 public void exitRule(ParseTreeListener listener) { 13703 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13704 } 13705 @Override 13706 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13707 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13708 else return visitor.visitChildren(this); 13709 } 13710 } 13711 13712 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13713 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13714 enterRule(_localctx, 134, RULE_singletonTagName); 13715 int _la; 13716 try { 13717 enterOuterAlt(_localctx, 1); 13718 { 13719 setState(1546); 13720 _la = _input.LA(1); 13721 if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) { 13722 _errHandler.recoverInline(this); 13723 } 13724 else { 13725 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13726 _errHandler.reportMatch(this); 13727 consume(); 13728 } 13729 } 13730 } 13731 catch (RecognitionException re) { 13732 _localctx.exception = re; 13733 _errHandler.reportError(this, re); 13734 _errHandler.recover(this, re); 13735 } 13736 finally { 13737 exitRule(); 13738 } 13739 return _localctx; 13740 } 13741 13742 public static class DescriptionContext extends ParserRuleContext { 13743 public List<HtmlCommentContext> htmlComment() { 13744 return getRuleContexts(HtmlCommentContext.class); 13745 } 13746 public HtmlCommentContext htmlComment(int i) { 13747 return getRuleContext(HtmlCommentContext.class,i); 13748 } 13749 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13750 public TerminalNode CDATA(int i) { 13751 return getToken(JavadocParser.CDATA, i); 13752 } 13753 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13754 public TerminalNode NEWLINE(int i) { 13755 return getToken(JavadocParser.NEWLINE, i); 13756 } 13757 public List<TextContext> text() { 13758 return getRuleContexts(TextContext.class); 13759 } 13760 public TextContext text(int i) { 13761 return getRuleContext(TextContext.class,i); 13762 } 13763 public List<JavadocInlineTagContext> javadocInlineTag() { 13764 return getRuleContexts(JavadocInlineTagContext.class); 13765 } 13766 public JavadocInlineTagContext javadocInlineTag(int i) { 13767 return getRuleContext(JavadocInlineTagContext.class,i); 13768 } 13769 public List<HtmlElementContext> htmlElement() { 13770 return getRuleContexts(HtmlElementContext.class); 13771 } 13772 public HtmlElementContext htmlElement(int i) { 13773 return getRuleContext(HtmlElementContext.class,i); 13774 } 13775 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13776 public TerminalNode LEADING_ASTERISK(int i) { 13777 return getToken(JavadocParser.LEADING_ASTERISK, i); 13778 } 13779 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13780 super(parent, invokingState); 13781 } 13782 @Override public int getRuleIndex() { return RULE_description; } 13783 @Override 13784 public void enterRule(ParseTreeListener listener) { 13785 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13786 } 13787 @Override 13788 public void exitRule(ParseTreeListener listener) { 13789 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13790 } 13791 @Override 13792 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13793 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13794 else return visitor.visitChildren(this); 13795 } 13796 } 13797 13798 public final DescriptionContext description() throws RecognitionException { 13799 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13800 enterRule(_localctx, 136, RULE_description); 13801 try { 13802 int _alt; 13803 enterOuterAlt(_localctx, 1); 13804 { 13805 setState(1556); 13806 _errHandler.sync(this); 13807 _alt = 1; 13808 do { 13809 switch (_alt) { 13810 case 1: 13811 { 13812 setState(1556); 13813 _errHandler.sync(this); 13814 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13815 case 1: 13816 { 13817 { 13818 setState(1548); 13819 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13820 setState(1549); 13821 match(LEADING_ASTERISK); 13822 } 13823 } 13824 break; 13825 case 2: 13826 { 13827 setState(1550); 13828 htmlComment(); 13829 } 13830 break; 13831 case 3: 13832 { 13833 setState(1551); 13834 match(CDATA); 13835 } 13836 break; 13837 case 4: 13838 { 13839 setState(1552); 13840 match(NEWLINE); 13841 } 13842 break; 13843 case 5: 13844 { 13845 setState(1553); 13846 text(); 13847 } 13848 break; 13849 case 6: 13850 { 13851 setState(1554); 13852 javadocInlineTag(); 13853 } 13854 break; 13855 case 7: 13856 { 13857 setState(1555); 13858 htmlElement(); 13859 } 13860 break; 13861 } 13862 } 13863 break; 13864 default: 13865 throw new NoViableAltException(this); 13866 } 13867 setState(1558); 13868 _errHandler.sync(this); 13869 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13870 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13871 } 13872 } 13873 catch (RecognitionException re) { 13874 _localctx.exception = re; 13875 _errHandler.reportError(this, re); 13876 _errHandler.recover(this, re); 13877 } 13878 finally { 13879 exitRule(); 13880 } 13881 return _localctx; 13882 } 13883 13884 public static class ReferenceContext extends ParserRuleContext { 13885 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13886 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13887 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13888 public ParametersContext parameters() { 13889 return getRuleContext(ParametersContext.class,0); 13890 } 13891 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13892 public TerminalNode DOT(int i) { 13893 return getToken(JavadocParser.DOT, i); 13894 } 13895 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13896 public TerminalNode CLASS(int i) { 13897 return getToken(JavadocParser.CLASS, i); 13898 } 13899 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13900 super(parent, invokingState); 13901 } 13902 @Override public int getRuleIndex() { return RULE_reference; } 13903 @Override 13904 public void enterRule(ParseTreeListener listener) { 13905 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13906 } 13907 @Override 13908 public void exitRule(ParseTreeListener listener) { 13909 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13910 } 13911 @Override 13912 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13913 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13914 else return visitor.visitChildren(this); 13915 } 13916 } 13917 13918 public final ReferenceContext reference() throws RecognitionException { 13919 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13920 enterRule(_localctx, 138, RULE_reference); 13921 int _la; 13922 try { 13923 int _alt; 13924 enterOuterAlt(_localctx, 1); 13925 { 13926 setState(1597); 13927 _errHandler.sync(this); 13928 switch (_input.LA(1)) { 13929 case PACKAGE: 13930 { 13931 setState(1560); 13932 match(PACKAGE); 13933 setState(1564); 13934 _errHandler.sync(this); 13935 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13936 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13937 if ( _alt==1 ) { 13938 { 13939 { 13940 setState(1561); 13941 _la = _input.LA(1); 13942 if ( !(_la==DOT || _la==CLASS) ) { 13943 _errHandler.recoverInline(this); 13944 } 13945 else { 13946 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13947 _errHandler.reportMatch(this); 13948 consume(); 13949 } 13950 } 13951 } 13952 } 13953 setState(1566); 13954 _errHandler.sync(this); 13955 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13956 } 13957 setState(1568); 13958 _errHandler.sync(this); 13959 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13960 case 1: 13961 { 13962 setState(1567); 13963 match(HASH); 13964 } 13965 break; 13966 } 13967 setState(1571); 13968 _errHandler.sync(this); 13969 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13970 case 1: 13971 { 13972 setState(1570); 13973 match(MEMBER); 13974 } 13975 break; 13976 } 13977 setState(1574); 13978 _errHandler.sync(this); 13979 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13980 case 1: 13981 { 13982 setState(1573); 13983 parameters(); 13984 } 13985 break; 13986 } 13987 } 13988 break; 13989 case DOT: 13990 case CLASS: 13991 { 13992 setState(1577); 13993 _errHandler.sync(this); 13994 _alt = 1; 13995 do { 13996 switch (_alt) { 13997 case 1: 13998 { 13999 { 14000 setState(1576); 14001 _la = _input.LA(1); 14002 if ( !(_la==DOT || _la==CLASS) ) { 14003 _errHandler.recoverInline(this); 14004 } 14005 else { 14006 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14007 _errHandler.reportMatch(this); 14008 consume(); 14009 } 14010 } 14011 } 14012 break; 14013 default: 14014 throw new NoViableAltException(this); 14015 } 14016 setState(1579); 14017 _errHandler.sync(this); 14018 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 14019 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14020 setState(1582); 14021 _errHandler.sync(this); 14022 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 14023 case 1: 14024 { 14025 setState(1581); 14026 match(HASH); 14027 } 14028 break; 14029 } 14030 setState(1585); 14031 _errHandler.sync(this); 14032 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 14033 case 1: 14034 { 14035 setState(1584); 14036 match(MEMBER); 14037 } 14038 break; 14039 } 14040 setState(1588); 14041 _errHandler.sync(this); 14042 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 14043 case 1: 14044 { 14045 setState(1587); 14046 parameters(); 14047 } 14048 break; 14049 } 14050 } 14051 break; 14052 case HASH: 14053 case MEMBER: 14054 { 14055 setState(1591); 14056 _errHandler.sync(this); 14057 _la = _input.LA(1); 14058 if (_la==HASH) { 14059 { 14060 setState(1590); 14061 match(HASH); 14062 } 14063 } 14064 14065 setState(1593); 14066 match(MEMBER); 14067 setState(1595); 14068 _errHandler.sync(this); 14069 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 14070 case 1: 14071 { 14072 setState(1594); 14073 parameters(); 14074 } 14075 break; 14076 } 14077 } 14078 break; 14079 default: 14080 throw new NoViableAltException(this); 14081 } 14082 } 14083 } 14084 catch (RecognitionException re) { 14085 _localctx.exception = re; 14086 _errHandler.reportError(this, re); 14087 _errHandler.recover(this, re); 14088 } 14089 finally { 14090 exitRule(); 14091 } 14092 return _localctx; 14093 } 14094 14095 public static class ParametersContext extends ParserRuleContext { 14096 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 14097 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 14098 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 14099 public TerminalNode ARGUMENT(int i) { 14100 return getToken(JavadocParser.ARGUMENT, i); 14101 } 14102 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 14103 public TerminalNode COMMA(int i) { 14104 return getToken(JavadocParser.COMMA, i); 14105 } 14106 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14107 public TerminalNode WS(int i) { 14108 return getToken(JavadocParser.WS, i); 14109 } 14110 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14111 public TerminalNode NEWLINE(int i) { 14112 return getToken(JavadocParser.NEWLINE, i); 14113 } 14114 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14115 public TerminalNode LEADING_ASTERISK(int i) { 14116 return getToken(JavadocParser.LEADING_ASTERISK, i); 14117 } 14118 public ParametersContext(ParserRuleContext parent, int invokingState) { 14119 super(parent, invokingState); 14120 } 14121 @Override public int getRuleIndex() { return RULE_parameters; } 14122 @Override 14123 public void enterRule(ParseTreeListener listener) { 14124 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 14125 } 14126 @Override 14127 public void exitRule(ParseTreeListener listener) { 14128 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 14129 } 14130 @Override 14131 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14132 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 14133 else return visitor.visitChildren(this); 14134 } 14135 } 14136 14137 public final ParametersContext parameters() throws RecognitionException { 14138 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 14139 enterRule(_localctx, 140, RULE_parameters); 14140 int _la; 14141 try { 14142 enterOuterAlt(_localctx, 1); 14143 { 14144 setState(1599); 14145 match(LEFT_BRACE); 14146 setState(1603); 14147 _errHandler.sync(this); 14148 _la = _input.LA(1); 14149 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 14150 { 14151 { 14152 setState(1600); 14153 _la = _input.LA(1); 14154 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 14155 _errHandler.recoverInline(this); 14156 } 14157 else { 14158 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14159 _errHandler.reportMatch(this); 14160 consume(); 14161 } 14162 } 14163 } 14164 setState(1605); 14165 _errHandler.sync(this); 14166 _la = _input.LA(1); 14167 } 14168 setState(1606); 14169 match(RIGHT_BRACE); 14170 } 14171 } 14172 catch (RecognitionException re) { 14173 _localctx.exception = re; 14174 _errHandler.reportError(this, re); 14175 _errHandler.recover(this, re); 14176 } 14177 finally { 14178 exitRule(); 14179 } 14180 return _localctx; 14181 } 14182 14183 public static class JavadocTagContext extends ParserRuleContext { 14184 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14185 public DescriptionContext description() { 14186 return getRuleContext(DescriptionContext.class,0); 14187 } 14188 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14189 public TerminalNode WS(int i) { 14190 return getToken(JavadocParser.WS, i); 14191 } 14192 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14193 public TerminalNode NEWLINE(int i) { 14194 return getToken(JavadocParser.NEWLINE, i); 14195 } 14196 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14197 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14198 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14199 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14200 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14201 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14202 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14203 public ReferenceContext reference() { 14204 return getRuleContext(ReferenceContext.class,0); 14205 } 14206 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14207 public TerminalNode STRING(int i) { 14208 return getToken(JavadocParser.STRING, i); 14209 } 14210 public List<HtmlElementContext> htmlElement() { 14211 return getRuleContexts(HtmlElementContext.class); 14212 } 14213 public HtmlElementContext htmlElement(int i) { 14214 return getRuleContext(HtmlElementContext.class,i); 14215 } 14216 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14217 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14218 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14219 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14220 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14221 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14222 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14223 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14224 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14225 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14226 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14227 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14228 super(parent, invokingState); 14229 } 14230 @Override public int getRuleIndex() { return RULE_javadocTag; } 14231 @Override 14232 public void enterRule(ParseTreeListener listener) { 14233 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14234 } 14235 @Override 14236 public void exitRule(ParseTreeListener listener) { 14237 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14238 } 14239 @Override 14240 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14241 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14242 else return visitor.visitChildren(this); 14243 } 14244 } 14245 14246 public final JavadocTagContext javadocTag() throws RecognitionException { 14247 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14248 enterRule(_localctx, 142, RULE_javadocTag); 14249 int _la; 14250 try { 14251 int _alt; 14252 setState(1802); 14253 _errHandler.sync(this); 14254 switch (_input.LA(1)) { 14255 case AUTHOR_LITERAL: 14256 enterOuterAlt(_localctx, 1); 14257 { 14258 setState(1608); 14259 match(AUTHOR_LITERAL); 14260 setState(1612); 14261 _errHandler.sync(this); 14262 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14263 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14264 if ( _alt==1 ) { 14265 { 14266 { 14267 setState(1609); 14268 _la = _input.LA(1); 14269 if ( !(_la==WS || _la==NEWLINE) ) { 14270 _errHandler.recoverInline(this); 14271 } 14272 else { 14273 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14274 _errHandler.reportMatch(this); 14275 consume(); 14276 } 14277 } 14278 } 14279 } 14280 setState(1614); 14281 _errHandler.sync(this); 14282 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14283 } 14284 setState(1616); 14285 _errHandler.sync(this); 14286 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14287 case 1: 14288 { 14289 setState(1615); 14290 description(); 14291 } 14292 break; 14293 } 14294 } 14295 break; 14296 case DEPRECATED_LITERAL: 14297 enterOuterAlt(_localctx, 2); 14298 { 14299 setState(1618); 14300 match(DEPRECATED_LITERAL); 14301 setState(1622); 14302 _errHandler.sync(this); 14303 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14304 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14305 if ( _alt==1 ) { 14306 { 14307 { 14308 setState(1619); 14309 _la = _input.LA(1); 14310 if ( !(_la==WS || _la==NEWLINE) ) { 14311 _errHandler.recoverInline(this); 14312 } 14313 else { 14314 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14315 _errHandler.reportMatch(this); 14316 consume(); 14317 } 14318 } 14319 } 14320 } 14321 setState(1624); 14322 _errHandler.sync(this); 14323 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14324 } 14325 setState(1626); 14326 _errHandler.sync(this); 14327 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14328 case 1: 14329 { 14330 setState(1625); 14331 description(); 14332 } 14333 break; 14334 } 14335 } 14336 break; 14337 case EXCEPTION_LITERAL: 14338 enterOuterAlt(_localctx, 3); 14339 { 14340 setState(1628); 14341 match(EXCEPTION_LITERAL); 14342 setState(1632); 14343 _errHandler.sync(this); 14344 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14345 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14346 if ( _alt==1 ) { 14347 { 14348 { 14349 setState(1629); 14350 _la = _input.LA(1); 14351 if ( !(_la==WS || _la==NEWLINE) ) { 14352 _errHandler.recoverInline(this); 14353 } 14354 else { 14355 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14356 _errHandler.reportMatch(this); 14357 consume(); 14358 } 14359 } 14360 } 14361 } 14362 setState(1634); 14363 _errHandler.sync(this); 14364 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14365 } 14366 setState(1636); 14367 _errHandler.sync(this); 14368 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14369 case 1: 14370 { 14371 setState(1635); 14372 match(CLASS_NAME); 14373 } 14374 break; 14375 } 14376 setState(1641); 14377 _errHandler.sync(this); 14378 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14379 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14380 if ( _alt==1 ) { 14381 { 14382 { 14383 setState(1638); 14384 _la = _input.LA(1); 14385 if ( !(_la==WS || _la==NEWLINE) ) { 14386 _errHandler.recoverInline(this); 14387 } 14388 else { 14389 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14390 _errHandler.reportMatch(this); 14391 consume(); 14392 } 14393 } 14394 } 14395 } 14396 setState(1643); 14397 _errHandler.sync(this); 14398 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14399 } 14400 setState(1645); 14401 _errHandler.sync(this); 14402 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14403 case 1: 14404 { 14405 setState(1644); 14406 description(); 14407 } 14408 break; 14409 } 14410 } 14411 break; 14412 case PARAM_LITERAL: 14413 enterOuterAlt(_localctx, 4); 14414 { 14415 setState(1647); 14416 match(PARAM_LITERAL); 14417 setState(1651); 14418 _errHandler.sync(this); 14419 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14420 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14421 if ( _alt==1 ) { 14422 { 14423 { 14424 setState(1648); 14425 _la = _input.LA(1); 14426 if ( !(_la==WS || _la==NEWLINE) ) { 14427 _errHandler.recoverInline(this); 14428 } 14429 else { 14430 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14431 _errHandler.reportMatch(this); 14432 consume(); 14433 } 14434 } 14435 } 14436 } 14437 setState(1653); 14438 _errHandler.sync(this); 14439 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14440 } 14441 setState(1655); 14442 _errHandler.sync(this); 14443 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14444 case 1: 14445 { 14446 setState(1654); 14447 match(PARAMETER_NAME); 14448 } 14449 break; 14450 } 14451 setState(1660); 14452 _errHandler.sync(this); 14453 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14454 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14455 if ( _alt==1 ) { 14456 { 14457 { 14458 setState(1657); 14459 _la = _input.LA(1); 14460 if ( !(_la==WS || _la==NEWLINE) ) { 14461 _errHandler.recoverInline(this); 14462 } 14463 else { 14464 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14465 _errHandler.reportMatch(this); 14466 consume(); 14467 } 14468 } 14469 } 14470 } 14471 setState(1662); 14472 _errHandler.sync(this); 14473 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14474 } 14475 setState(1664); 14476 _errHandler.sync(this); 14477 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14478 case 1: 14479 { 14480 setState(1663); 14481 description(); 14482 } 14483 break; 14484 } 14485 } 14486 break; 14487 case RETURN_LITERAL: 14488 enterOuterAlt(_localctx, 5); 14489 { 14490 setState(1666); 14491 match(RETURN_LITERAL); 14492 setState(1670); 14493 _errHandler.sync(this); 14494 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14495 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14496 if ( _alt==1 ) { 14497 { 14498 { 14499 setState(1667); 14500 _la = _input.LA(1); 14501 if ( !(_la==WS || _la==NEWLINE) ) { 14502 _errHandler.recoverInline(this); 14503 } 14504 else { 14505 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14506 _errHandler.reportMatch(this); 14507 consume(); 14508 } 14509 } 14510 } 14511 } 14512 setState(1672); 14513 _errHandler.sync(this); 14514 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14515 } 14516 setState(1674); 14517 _errHandler.sync(this); 14518 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14519 case 1: 14520 { 14521 setState(1673); 14522 description(); 14523 } 14524 break; 14525 } 14526 } 14527 break; 14528 case SEE_LITERAL: 14529 enterOuterAlt(_localctx, 6); 14530 { 14531 setState(1676); 14532 match(SEE_LITERAL); 14533 setState(1680); 14534 _errHandler.sync(this); 14535 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14536 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14537 if ( _alt==1 ) { 14538 { 14539 { 14540 setState(1677); 14541 _la = _input.LA(1); 14542 if ( !(_la==WS || _la==NEWLINE) ) { 14543 _errHandler.recoverInline(this); 14544 } 14545 else { 14546 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14547 _errHandler.reportMatch(this); 14548 consume(); 14549 } 14550 } 14551 } 14552 } 14553 setState(1682); 14554 _errHandler.sync(this); 14555 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14556 } 14557 setState(1684); 14558 _errHandler.sync(this); 14559 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14560 case 1: 14561 { 14562 setState(1683); 14563 reference(); 14564 } 14565 break; 14566 } 14567 setState(1690); 14568 _errHandler.sync(this); 14569 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14570 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14571 if ( _alt==1 ) { 14572 { 14573 setState(1688); 14574 _errHandler.sync(this); 14575 switch (_input.LA(1)) { 14576 case STRING: 14577 { 14578 setState(1686); 14579 match(STRING); 14580 } 14581 break; 14582 case OPEN: 14583 { 14584 setState(1687); 14585 htmlElement(); 14586 } 14587 break; 14588 default: 14589 throw new NoViableAltException(this); 14590 } 14591 } 14592 } 14593 setState(1692); 14594 _errHandler.sync(this); 14595 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14596 } 14597 setState(1696); 14598 _errHandler.sync(this); 14599 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14600 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14601 if ( _alt==1 ) { 14602 { 14603 { 14604 setState(1693); 14605 _la = _input.LA(1); 14606 if ( !(_la==WS || _la==NEWLINE) ) { 14607 _errHandler.recoverInline(this); 14608 } 14609 else { 14610 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14611 _errHandler.reportMatch(this); 14612 consume(); 14613 } 14614 } 14615 } 14616 } 14617 setState(1698); 14618 _errHandler.sync(this); 14619 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14620 } 14621 setState(1700); 14622 _errHandler.sync(this); 14623 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14624 case 1: 14625 { 14626 setState(1699); 14627 description(); 14628 } 14629 break; 14630 } 14631 } 14632 break; 14633 case SERIAL_LITERAL: 14634 enterOuterAlt(_localctx, 7); 14635 { 14636 setState(1702); 14637 match(SERIAL_LITERAL); 14638 setState(1706); 14639 _errHandler.sync(this); 14640 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14641 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14642 if ( _alt==1 ) { 14643 { 14644 { 14645 setState(1703); 14646 _la = _input.LA(1); 14647 if ( !(_la==WS || _la==NEWLINE) ) { 14648 _errHandler.recoverInline(this); 14649 } 14650 else { 14651 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14652 _errHandler.reportMatch(this); 14653 consume(); 14654 } 14655 } 14656 } 14657 } 14658 setState(1708); 14659 _errHandler.sync(this); 14660 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14661 } 14662 setState(1710); 14663 _errHandler.sync(this); 14664 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14665 case 1: 14666 { 14667 setState(1709); 14668 _la = _input.LA(1); 14669 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14670 _errHandler.recoverInline(this); 14671 } 14672 else { 14673 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14674 _errHandler.reportMatch(this); 14675 consume(); 14676 } 14677 } 14678 break; 14679 } 14680 setState(1713); 14681 _errHandler.sync(this); 14682 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14683 case 1: 14684 { 14685 setState(1712); 14686 description(); 14687 } 14688 break; 14689 } 14690 } 14691 break; 14692 case SERIAL_DATA_LITERAL: 14693 enterOuterAlt(_localctx, 8); 14694 { 14695 setState(1715); 14696 match(SERIAL_DATA_LITERAL); 14697 setState(1719); 14698 _errHandler.sync(this); 14699 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14700 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14701 if ( _alt==1 ) { 14702 { 14703 { 14704 setState(1716); 14705 _la = _input.LA(1); 14706 if ( !(_la==WS || _la==NEWLINE) ) { 14707 _errHandler.recoverInline(this); 14708 } 14709 else { 14710 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14711 _errHandler.reportMatch(this); 14712 consume(); 14713 } 14714 } 14715 } 14716 } 14717 setState(1721); 14718 _errHandler.sync(this); 14719 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14720 } 14721 setState(1723); 14722 _errHandler.sync(this); 14723 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14724 case 1: 14725 { 14726 setState(1722); 14727 description(); 14728 } 14729 break; 14730 } 14731 } 14732 break; 14733 case SERIAL_FIELD_LITERAL: 14734 enterOuterAlt(_localctx, 9); 14735 { 14736 setState(1725); 14737 match(SERIAL_FIELD_LITERAL); 14738 setState(1729); 14739 _errHandler.sync(this); 14740 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14741 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14742 if ( _alt==1 ) { 14743 { 14744 { 14745 setState(1726); 14746 _la = _input.LA(1); 14747 if ( !(_la==WS || _la==NEWLINE) ) { 14748 _errHandler.recoverInline(this); 14749 } 14750 else { 14751 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14752 _errHandler.reportMatch(this); 14753 consume(); 14754 } 14755 } 14756 } 14757 } 14758 setState(1731); 14759 _errHandler.sync(this); 14760 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14761 } 14762 setState(1733); 14763 _errHandler.sync(this); 14764 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14765 case 1: 14766 { 14767 setState(1732); 14768 match(FIELD_NAME); 14769 } 14770 break; 14771 } 14772 setState(1738); 14773 _errHandler.sync(this); 14774 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14775 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14776 if ( _alt==1 ) { 14777 { 14778 { 14779 setState(1735); 14780 _la = _input.LA(1); 14781 if ( !(_la==WS || _la==NEWLINE) ) { 14782 _errHandler.recoverInline(this); 14783 } 14784 else { 14785 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14786 _errHandler.reportMatch(this); 14787 consume(); 14788 } 14789 } 14790 } 14791 } 14792 setState(1740); 14793 _errHandler.sync(this); 14794 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14795 } 14796 setState(1742); 14797 _errHandler.sync(this); 14798 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14799 case 1: 14800 { 14801 setState(1741); 14802 match(FIELD_TYPE); 14803 } 14804 break; 14805 } 14806 setState(1747); 14807 _errHandler.sync(this); 14808 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14809 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14810 if ( _alt==1 ) { 14811 { 14812 { 14813 setState(1744); 14814 _la = _input.LA(1); 14815 if ( !(_la==WS || _la==NEWLINE) ) { 14816 _errHandler.recoverInline(this); 14817 } 14818 else { 14819 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14820 _errHandler.reportMatch(this); 14821 consume(); 14822 } 14823 } 14824 } 14825 } 14826 setState(1749); 14827 _errHandler.sync(this); 14828 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14829 } 14830 setState(1751); 14831 _errHandler.sync(this); 14832 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14833 case 1: 14834 { 14835 setState(1750); 14836 description(); 14837 } 14838 break; 14839 } 14840 } 14841 break; 14842 case SINCE_LITERAL: 14843 enterOuterAlt(_localctx, 10); 14844 { 14845 setState(1753); 14846 match(SINCE_LITERAL); 14847 setState(1757); 14848 _errHandler.sync(this); 14849 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14850 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14851 if ( _alt==1 ) { 14852 { 14853 { 14854 setState(1754); 14855 _la = _input.LA(1); 14856 if ( !(_la==WS || _la==NEWLINE) ) { 14857 _errHandler.recoverInline(this); 14858 } 14859 else { 14860 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14861 _errHandler.reportMatch(this); 14862 consume(); 14863 } 14864 } 14865 } 14866 } 14867 setState(1759); 14868 _errHandler.sync(this); 14869 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14870 } 14871 setState(1761); 14872 _errHandler.sync(this); 14873 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14874 case 1: 14875 { 14876 setState(1760); 14877 description(); 14878 } 14879 break; 14880 } 14881 } 14882 break; 14883 case THROWS_LITERAL: 14884 enterOuterAlt(_localctx, 11); 14885 { 14886 setState(1763); 14887 match(THROWS_LITERAL); 14888 setState(1767); 14889 _errHandler.sync(this); 14890 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14891 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14892 if ( _alt==1 ) { 14893 { 14894 { 14895 setState(1764); 14896 _la = _input.LA(1); 14897 if ( !(_la==WS || _la==NEWLINE) ) { 14898 _errHandler.recoverInline(this); 14899 } 14900 else { 14901 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14902 _errHandler.reportMatch(this); 14903 consume(); 14904 } 14905 } 14906 } 14907 } 14908 setState(1769); 14909 _errHandler.sync(this); 14910 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14911 } 14912 setState(1771); 14913 _errHandler.sync(this); 14914 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14915 case 1: 14916 { 14917 setState(1770); 14918 match(CLASS_NAME); 14919 } 14920 break; 14921 } 14922 setState(1776); 14923 _errHandler.sync(this); 14924 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14925 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14926 if ( _alt==1 ) { 14927 { 14928 { 14929 setState(1773); 14930 _la = _input.LA(1); 14931 if ( !(_la==WS || _la==NEWLINE) ) { 14932 _errHandler.recoverInline(this); 14933 } 14934 else { 14935 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14936 _errHandler.reportMatch(this); 14937 consume(); 14938 } 14939 } 14940 } 14941 } 14942 setState(1778); 14943 _errHandler.sync(this); 14944 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14945 } 14946 setState(1780); 14947 _errHandler.sync(this); 14948 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14949 case 1: 14950 { 14951 setState(1779); 14952 description(); 14953 } 14954 break; 14955 } 14956 } 14957 break; 14958 case VERSION_LITERAL: 14959 enterOuterAlt(_localctx, 12); 14960 { 14961 setState(1782); 14962 match(VERSION_LITERAL); 14963 setState(1786); 14964 _errHandler.sync(this); 14965 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14966 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14967 if ( _alt==1 ) { 14968 { 14969 { 14970 setState(1783); 14971 _la = _input.LA(1); 14972 if ( !(_la==WS || _la==NEWLINE) ) { 14973 _errHandler.recoverInline(this); 14974 } 14975 else { 14976 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14977 _errHandler.reportMatch(this); 14978 consume(); 14979 } 14980 } 14981 } 14982 } 14983 setState(1788); 14984 _errHandler.sync(this); 14985 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14986 } 14987 setState(1790); 14988 _errHandler.sync(this); 14989 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14990 case 1: 14991 { 14992 setState(1789); 14993 description(); 14994 } 14995 break; 14996 } 14997 } 14998 break; 14999 case CUSTOM_NAME: 15000 enterOuterAlt(_localctx, 13); 15001 { 15002 setState(1792); 15003 match(CUSTOM_NAME); 15004 setState(1796); 15005 _errHandler.sync(this); 15006 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 15007 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15008 if ( _alt==1 ) { 15009 { 15010 { 15011 setState(1793); 15012 _la = _input.LA(1); 15013 if ( !(_la==WS || _la==NEWLINE) ) { 15014 _errHandler.recoverInline(this); 15015 } 15016 else { 15017 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15018 _errHandler.reportMatch(this); 15019 consume(); 15020 } 15021 } 15022 } 15023 } 15024 setState(1798); 15025 _errHandler.sync(this); 15026 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 15027 } 15028 setState(1800); 15029 _errHandler.sync(this); 15030 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 15031 case 1: 15032 { 15033 setState(1799); 15034 description(); 15035 } 15036 break; 15037 } 15038 } 15039 break; 15040 default: 15041 throw new NoViableAltException(this); 15042 } 15043 } 15044 catch (RecognitionException re) { 15045 _localctx.exception = re; 15046 _errHandler.reportError(this, re); 15047 _errHandler.recover(this, re); 15048 } 15049 finally { 15050 exitRule(); 15051 } 15052 return _localctx; 15053 } 15054 15055 public static class JavadocInlineTagContext extends ParserRuleContext { 15056 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 15057 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 15058 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 15059 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 15060 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 15061 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 15062 public ReferenceContext reference() { 15063 return getRuleContext(ReferenceContext.class,0); 15064 } 15065 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 15066 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 15067 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 15068 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 15069 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15070 public TerminalNode WS(int i) { 15071 return getToken(JavadocParser.WS, i); 15072 } 15073 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15074 public TerminalNode NEWLINE(int i) { 15075 return getToken(JavadocParser.NEWLINE, i); 15076 } 15077 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15078 public TerminalNode LEADING_ASTERISK(int i) { 15079 return getToken(JavadocParser.LEADING_ASTERISK, i); 15080 } 15081 public List<TextContext> text() { 15082 return getRuleContexts(TextContext.class); 15083 } 15084 public TextContext text(int i) { 15085 return getRuleContext(TextContext.class,i); 15086 } 15087 public DescriptionContext description() { 15088 return getRuleContext(DescriptionContext.class,0); 15089 } 15090 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 15091 super(parent, invokingState); 15092 } 15093 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 15094 @Override 15095 public void enterRule(ParseTreeListener listener) { 15096 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 15097 } 15098 @Override 15099 public void exitRule(ParseTreeListener listener) { 15100 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 15101 } 15102 @Override 15103 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15104 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 15105 else return visitor.visitChildren(this); 15106 } 15107 } 15108 15109 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 15110 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 15111 enterRule(_localctx, 144, RULE_javadocInlineTag); 15112 int _la; 15113 try { 15114 int _alt; 15115 enterOuterAlt(_localctx, 1); 15116 { 15117 setState(1804); 15118 match(JAVADOC_INLINE_TAG_START); 15119 setState(1881); 15120 _errHandler.sync(this); 15121 switch (_input.LA(1)) { 15122 case CODE_LITERAL: 15123 { 15124 setState(1805); 15125 match(CODE_LITERAL); 15126 setState(1812); 15127 _errHandler.sync(this); 15128 _la = _input.LA(1); 15129 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15130 { 15131 setState(1810); 15132 _errHandler.sync(this); 15133 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 15134 case 1: 15135 { 15136 setState(1806); 15137 match(WS); 15138 } 15139 break; 15140 case 2: 15141 { 15142 setState(1807); 15143 match(NEWLINE); 15144 } 15145 break; 15146 case 3: 15147 { 15148 setState(1808); 15149 match(LEADING_ASTERISK); 15150 } 15151 break; 15152 case 4: 15153 { 15154 setState(1809); 15155 text(); 15156 } 15157 break; 15158 } 15159 } 15160 setState(1814); 15161 _errHandler.sync(this); 15162 _la = _input.LA(1); 15163 } 15164 } 15165 break; 15166 case DOC_ROOT_LITERAL: 15167 { 15168 setState(1815); 15169 match(DOC_ROOT_LITERAL); 15170 setState(1819); 15171 _errHandler.sync(this); 15172 _la = _input.LA(1); 15173 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15174 { 15175 { 15176 setState(1816); 15177 _la = _input.LA(1); 15178 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15179 _errHandler.recoverInline(this); 15180 } 15181 else { 15182 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15183 _errHandler.reportMatch(this); 15184 consume(); 15185 } 15186 } 15187 } 15188 setState(1821); 15189 _errHandler.sync(this); 15190 _la = _input.LA(1); 15191 } 15192 } 15193 break; 15194 case INHERIT_DOC_LITERAL: 15195 { 15196 setState(1822); 15197 match(INHERIT_DOC_LITERAL); 15198 setState(1826); 15199 _errHandler.sync(this); 15200 _la = _input.LA(1); 15201 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15202 { 15203 { 15204 setState(1823); 15205 _la = _input.LA(1); 15206 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15207 _errHandler.recoverInline(this); 15208 } 15209 else { 15210 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15211 _errHandler.reportMatch(this); 15212 consume(); 15213 } 15214 } 15215 } 15216 setState(1828); 15217 _errHandler.sync(this); 15218 _la = _input.LA(1); 15219 } 15220 } 15221 break; 15222 case LINK_LITERAL: 15223 { 15224 setState(1829); 15225 match(LINK_LITERAL); 15226 setState(1833); 15227 _errHandler.sync(this); 15228 _la = _input.LA(1); 15229 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15230 { 15231 { 15232 setState(1830); 15233 _la = _input.LA(1); 15234 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15235 _errHandler.recoverInline(this); 15236 } 15237 else { 15238 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15239 _errHandler.reportMatch(this); 15240 consume(); 15241 } 15242 } 15243 } 15244 setState(1835); 15245 _errHandler.sync(this); 15246 _la = _input.LA(1); 15247 } 15248 setState(1836); 15249 reference(); 15250 setState(1838); 15251 _errHandler.sync(this); 15252 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 15253 case 1: 15254 { 15255 setState(1837); 15256 description(); 15257 } 15258 break; 15259 } 15260 } 15261 break; 15262 case LINKPLAIN_LITERAL: 15263 { 15264 setState(1840); 15265 match(LINKPLAIN_LITERAL); 15266 setState(1844); 15267 _errHandler.sync(this); 15268 _la = _input.LA(1); 15269 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15270 { 15271 { 15272 setState(1841); 15273 _la = _input.LA(1); 15274 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15275 _errHandler.recoverInline(this); 15276 } 15277 else { 15278 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15279 _errHandler.reportMatch(this); 15280 consume(); 15281 } 15282 } 15283 } 15284 setState(1846); 15285 _errHandler.sync(this); 15286 _la = _input.LA(1); 15287 } 15288 setState(1847); 15289 reference(); 15290 setState(1849); 15291 _errHandler.sync(this); 15292 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15293 case 1: 15294 { 15295 setState(1848); 15296 description(); 15297 } 15298 break; 15299 } 15300 } 15301 break; 15302 case LITERAL_LITERAL: 15303 { 15304 setState(1851); 15305 match(LITERAL_LITERAL); 15306 setState(1858); 15307 _errHandler.sync(this); 15308 _la = _input.LA(1); 15309 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15310 { 15311 setState(1856); 15312 _errHandler.sync(this); 15313 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15314 case 1: 15315 { 15316 setState(1852); 15317 match(WS); 15318 } 15319 break; 15320 case 2: 15321 { 15322 setState(1853); 15323 match(NEWLINE); 15324 } 15325 break; 15326 case 3: 15327 { 15328 setState(1854); 15329 match(LEADING_ASTERISK); 15330 } 15331 break; 15332 case 4: 15333 { 15334 setState(1855); 15335 text(); 15336 } 15337 break; 15338 } 15339 } 15340 setState(1860); 15341 _errHandler.sync(this); 15342 _la = _input.LA(1); 15343 } 15344 } 15345 break; 15346 case VALUE_LITERAL: 15347 { 15348 setState(1861); 15349 match(VALUE_LITERAL); 15350 setState(1865); 15351 _errHandler.sync(this); 15352 _la = _input.LA(1); 15353 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15354 { 15355 { 15356 setState(1862); 15357 _la = _input.LA(1); 15358 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15359 _errHandler.recoverInline(this); 15360 } 15361 else { 15362 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15363 _errHandler.reportMatch(this); 15364 consume(); 15365 } 15366 } 15367 } 15368 setState(1867); 15369 _errHandler.sync(this); 15370 _la = _input.LA(1); 15371 } 15372 setState(1869); 15373 _errHandler.sync(this); 15374 _la = _input.LA(1); 15375 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15376 { 15377 setState(1868); 15378 reference(); 15379 } 15380 } 15381 15382 } 15383 break; 15384 case CUSTOM_NAME: 15385 { 15386 setState(1871); 15387 match(CUSTOM_NAME); 15388 setState(1875); 15389 _errHandler.sync(this); 15390 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15391 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15392 if ( _alt==1 ) { 15393 { 15394 { 15395 setState(1872); 15396 _la = _input.LA(1); 15397 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15398 _errHandler.recoverInline(this); 15399 } 15400 else { 15401 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15402 _errHandler.reportMatch(this); 15403 consume(); 15404 } 15405 } 15406 } 15407 } 15408 setState(1877); 15409 _errHandler.sync(this); 15410 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15411 } 15412 setState(1879); 15413 _errHandler.sync(this); 15414 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15415 case 1: 15416 { 15417 setState(1878); 15418 description(); 15419 } 15420 break; 15421 } 15422 } 15423 break; 15424 default: 15425 throw new NoViableAltException(this); 15426 } 15427 setState(1883); 15428 match(JAVADOC_INLINE_TAG_END); 15429 } 15430 } 15431 catch (RecognitionException re) { 15432 _localctx.exception = re; 15433 _errHandler.reportError(this, re); 15434 _errHandler.recover(this, re); 15435 } 15436 finally { 15437 exitRule(); 15438 } 15439 return _localctx; 15440 } 15441 15442 public static class HtmlCommentContext extends ParserRuleContext { 15443 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15444 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15445 public List<TextContext> text() { 15446 return getRuleContexts(TextContext.class); 15447 } 15448 public TextContext text(int i) { 15449 return getRuleContext(TextContext.class,i); 15450 } 15451 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15452 public TerminalNode NEWLINE(int i) { 15453 return getToken(JavadocParser.NEWLINE, i); 15454 } 15455 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15456 public TerminalNode LEADING_ASTERISK(int i) { 15457 return getToken(JavadocParser.LEADING_ASTERISK, i); 15458 } 15459 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15460 super(parent, invokingState); 15461 } 15462 @Override public int getRuleIndex() { return RULE_htmlComment; } 15463 @Override 15464 public void enterRule(ParseTreeListener listener) { 15465 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15466 } 15467 @Override 15468 public void exitRule(ParseTreeListener listener) { 15469 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15470 } 15471 @Override 15472 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15473 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15474 else return visitor.visitChildren(this); 15475 } 15476 } 15477 15478 public final HtmlCommentContext htmlComment() throws RecognitionException { 15479 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15480 enterRule(_localctx, 146, RULE_htmlComment); 15481 int _la; 15482 try { 15483 enterOuterAlt(_localctx, 1); 15484 { 15485 setState(1885); 15486 match(HTML_COMMENT_START); 15487 setState(1891); 15488 _errHandler.sync(this); 15489 _la = _input.LA(1); 15490 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15491 { 15492 setState(1889); 15493 _errHandler.sync(this); 15494 switch (_input.LA(1)) { 15495 case WS: 15496 case CHAR: 15497 { 15498 setState(1886); 15499 text(); 15500 } 15501 break; 15502 case NEWLINE: 15503 { 15504 setState(1887); 15505 match(NEWLINE); 15506 } 15507 break; 15508 case LEADING_ASTERISK: 15509 { 15510 setState(1888); 15511 match(LEADING_ASTERISK); 15512 } 15513 break; 15514 default: 15515 throw new NoViableAltException(this); 15516 } 15517 } 15518 setState(1893); 15519 _errHandler.sync(this); 15520 _la = _input.LA(1); 15521 } 15522 setState(1894); 15523 match(HTML_COMMENT_END); 15524 } 15525 } 15526 catch (RecognitionException re) { 15527 _localctx.exception = re; 15528 _errHandler.reportError(this, re); 15529 _errHandler.recover(this, re); 15530 } 15531 finally { 15532 exitRule(); 15533 } 15534 return _localctx; 15535 } 15536 15537 public static class TextContext extends ParserRuleContext { 15538 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15539 public TerminalNode CHAR(int i) { 15540 return getToken(JavadocParser.CHAR, i); 15541 } 15542 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15543 public TerminalNode WS(int i) { 15544 return getToken(JavadocParser.WS, i); 15545 } 15546 public TextContext(ParserRuleContext parent, int invokingState) { 15547 super(parent, invokingState); 15548 } 15549 @Override public int getRuleIndex() { return RULE_text; } 15550 @Override 15551 public void enterRule(ParseTreeListener listener) { 15552 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15553 } 15554 @Override 15555 public void exitRule(ParseTreeListener listener) { 15556 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15557 } 15558 @Override 15559 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15560 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15561 else return visitor.visitChildren(this); 15562 } 15563 } 15564 15565 public final TextContext text() throws RecognitionException { 15566 TextContext _localctx = new TextContext(_ctx, getState()); 15567 enterRule(_localctx, 148, RULE_text); 15568 int _la; 15569 try { 15570 int _alt; 15571 enterOuterAlt(_localctx, 1); 15572 { 15573 setState(1898); 15574 _errHandler.sync(this); 15575 _alt = 1; 15576 do { 15577 switch (_alt) { 15578 case 1: 15579 { 15580 { 15581 setState(1896); 15582 _la = _input.LA(1); 15583 if ( !(_la==WS || _la==CHAR) ) { 15584 _errHandler.recoverInline(this); 15585 } 15586 else { 15587 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15588 _errHandler.reportMatch(this); 15589 consume(); 15590 } 15591 15592 _la = _input.LA(1); 15593 if ((_la != WS) && (_la != CHAR)) return _localctx; 15594 else if (_alt == 1) continue; 15595 15596 } 15597 } 15598 break; 15599 default: 15600 throw new NoViableAltException(this); 15601 } 15602 setState(1900); 15603 _errHandler.sync(this); 15604 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15605 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15606 } 15607 } 15608 catch (RecognitionException re) { 15609 _localctx.exception = re; 15610 _errHandler.reportError(this, re); 15611 _errHandler.recover(this, re); 15612 } 15613 finally { 15614 exitRule(); 15615 } 15616 return _localctx; 15617 } 15618 15619 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15620 switch (ruleIndex) { 15621 case 0: 15622 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15623 case 5: 15624 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15625 case 8: 15626 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15627 case 11: 15628 return li_sempred((LiContext)_localctx, predIndex); 15629 case 14: 15630 return tr_sempred((TrContext)_localctx, predIndex); 15631 case 17: 15632 return td_sempred((TdContext)_localctx, predIndex); 15633 case 20: 15634 return th_sempred((ThContext)_localctx, predIndex); 15635 case 23: 15636 return body_sempred((BodyContext)_localctx, predIndex); 15637 case 26: 15638 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15639 case 29: 15640 return dd_sempred((DdContext)_localctx, predIndex); 15641 case 32: 15642 return dt_sempred((DtContext)_localctx, predIndex); 15643 case 35: 15644 return head_sempred((HeadContext)_localctx, predIndex); 15645 case 38: 15646 return html_sempred((HtmlContext)_localctx, predIndex); 15647 case 41: 15648 return option_sempred((OptionContext)_localctx, predIndex); 15649 case 44: 15650 return tbody_sempred((TbodyContext)_localctx, predIndex); 15651 case 47: 15652 return tfoot_sempred((TfootContext)_localctx, predIndex); 15653 case 50: 15654 return thead_sempred((TheadContext)_localctx, predIndex); 15655 case 68: 15656 return description_sempred((DescriptionContext)_localctx, predIndex); 15657 } 15658 return true; 15659 } 15660 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15661 switch (predIndex) { 15662 case 0: 15663 return !isNextJavadocTag(); 15664 } 15665 return true; 15666 } 15667 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15668 switch (predIndex) { 15669 case 1: 15670 return !isNextJavadocTag(); 15671 case 2: 15672 return !isNextJavadocTag(); 15673 } 15674 return true; 15675 } 15676 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15677 switch (predIndex) { 15678 case 3: 15679 return !isNextJavadocTag(); 15680 } 15681 return true; 15682 } 15683 private boolean li_sempred(LiContext _localctx, int predIndex) { 15684 switch (predIndex) { 15685 case 4: 15686 return !isNextJavadocTag(); 15687 } 15688 return true; 15689 } 15690 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15691 switch (predIndex) { 15692 case 5: 15693 return !isNextJavadocTag(); 15694 } 15695 return true; 15696 } 15697 private boolean td_sempred(TdContext _localctx, int predIndex) { 15698 switch (predIndex) { 15699 case 6: 15700 return !isNextJavadocTag(); 15701 } 15702 return true; 15703 } 15704 private boolean th_sempred(ThContext _localctx, int predIndex) { 15705 switch (predIndex) { 15706 case 7: 15707 return !isNextJavadocTag(); 15708 } 15709 return true; 15710 } 15711 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15712 switch (predIndex) { 15713 case 8: 15714 return !isNextJavadocTag(); 15715 } 15716 return true; 15717 } 15718 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15719 switch (predIndex) { 15720 case 9: 15721 return !isNextJavadocTag(); 15722 } 15723 return true; 15724 } 15725 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15726 switch (predIndex) { 15727 case 10: 15728 return !isNextJavadocTag(); 15729 } 15730 return true; 15731 } 15732 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15733 switch (predIndex) { 15734 case 11: 15735 return !isNextJavadocTag(); 15736 } 15737 return true; 15738 } 15739 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15740 switch (predIndex) { 15741 case 12: 15742 return !isNextJavadocTag(); 15743 } 15744 return true; 15745 } 15746 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15747 switch (predIndex) { 15748 case 13: 15749 return !isNextJavadocTag(); 15750 } 15751 return true; 15752 } 15753 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15754 switch (predIndex) { 15755 case 14: 15756 return !isNextJavadocTag(); 15757 } 15758 return true; 15759 } 15760 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15761 switch (predIndex) { 15762 case 15: 15763 return !isNextJavadocTag(); 15764 } 15765 return true; 15766 } 15767 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15768 switch (predIndex) { 15769 case 16: 15770 return !isNextJavadocTag(); 15771 } 15772 return true; 15773 } 15774 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15775 switch (predIndex) { 15776 case 17: 15777 return !isNextJavadocTag(); 15778 } 15779 return true; 15780 } 15781 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15782 switch (predIndex) { 15783 case 18: 15784 return !isNextJavadocTag(); 15785 } 15786 return true; 15787 } 15788 15789 public static final String _serializedATN = 15790 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3]\u0771\4\2\t\2\4"+ 15791 "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ 15792 "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ 15793 "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ 15794 "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ 15795 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15796 ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ 15797 "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ 15798 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15799 "\tI\4J\tJ\4K\tK\4L\tL\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2\u00a1\n\2\f"+ 15800 "\2\16\2\u00a4\13\2\3\2\5\2\u00a7\n\2\3\2\7\2\u00aa\n\2\f\2\16\2\u00ad"+ 15801 "\13\2\3\2\7\2\u00b0\n\2\f\2\16\2\u00b3\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3"+ 15802 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 15803 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 15804 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00e6\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7"+ 15805 "\4\u00ee\n\4\f\4\16\4\u00f1\13\4\3\4\3\4\3\5\3\5\3\5\3\5\7\5\u00f9\n\5"+ 15806 "\f\5\16\5\u00fc\13\5\3\5\3\5\3\6\3\6\7\6\u0102\n\6\f\6\16\6\u0105\13\6"+ 15807 "\3\6\3\6\7\6\u0109\n\6\f\6\16\6\u010c\13\6\3\6\3\6\3\6\5\6\u0111\n\6\3"+ 15808 "\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u011c\n\7\f\7\16\7\u011f\13\7\3"+ 15809 "\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u012c\n\7\f\7\16\7\u012f"+ 15810 "\13\7\3\7\3\7\5\7\u0133\n\7\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u013b\n\b\f\b"+ 15811 "\16\b\u013e\13\b\3\b\3\b\3\t\3\t\3\t\3\t\7\t\u0146\n\t\f\t\16\t\u0149"+ 15812 "\13\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+ 15813 "\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+ 15814 "\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u0173\n\n\f\n\16\n\u0176\13\n\3\n\3\n\3"+ 15815 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15816 "\13\3\13\3\f\3\f\3\f\3\f\7\f\u018b\n\f\f\f\16\f\u018e\13\f\3\f\3\f\3\r"+ 15817 "\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+ 15818 "\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r"+ 15819 "\3\r\3\r\7\r\u01b8\n\r\f\r\16\r\u01bb\13\r\3\r\3\r\3\16\3\16\3\16\3\16"+ 15820 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15821 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15822 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 15823 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 15824 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u01fd\n\20\f\20\16\20\u0200"+ 15825 "\13\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u020a\n\21\f\21\16"+ 15826 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15827 "\22\u0218\13\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+ 15828 "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+ 15829 "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+ 15830 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15831 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15832 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15833 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 15834 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 15835 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u0287\n\26\f\26\16"+ 15836 "\26\u028a\13\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\7\27\u0294\n\27"+ 15837 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15838 "\f\30\16\30\u02a2\13\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 15839 "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 15840 "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 15841 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15842 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15843 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15844 "\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+ 15845 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3"+ 15846 "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u0311\n\34"+ 15847 "\f\34\16\34\u0314\13\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\7\35\u031e"+ 15848 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15849 "\n\36\f\36\16\36\u032c\13\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 15850 "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 15851 "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 15852 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15853 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15854 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15855 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15856 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15857 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15858 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15859 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15860 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15861 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15862 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15863 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15864 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15865 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15866 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15867 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15868 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15869 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15870 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15871 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15872 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15873 "\60\u04ca\13\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 15874 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 15875 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 15876 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15877 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15878 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15879 "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+ 15880 "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+ 15881 "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u0539\n\64\f\64\16"+ 15882 "\64\u053c\13\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65"+ 15883 "\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u054f\n\65\3\66\3\66\3\66\3\66\3\66"+ 15884 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15885 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15886 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15887 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15888 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15889 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15890 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15891 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15892 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15893 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15894 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15895 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15896 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15897 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15898 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15899 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15900 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15901 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15902 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15903 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15904 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15905 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15906 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15907 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15908 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15909 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15910 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15911 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15912 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15913 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15914 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15915 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15916 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15917 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15918 "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+ 15919 "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+ 15920 "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ 15921 "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ 15922 "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+ 15923 "\6\b\b\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b"+ 15924 "\3\2\30\31\4\2\6\6\32\32\2\u0a88\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7"+ 15925 "\3\2\2\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2"+ 15926 "\2\2\20\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2"+ 15927 "\2\30\u0191\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2"+ 15928 " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+ 15929 "\2\2\2*\u0260\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62"+ 15930 "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+ 15931 "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+ 15932 "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+ 15933 "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+ 15934 "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+ 15935 "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+ 15936 "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+ 15937 "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+ 15938 "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+ 15939 "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+ 15940 "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+ 15941 "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+ 15942 "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+ 15943 "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+ 15944 "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+ 15945 "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+ 15946 "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15947 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15948 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15949 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15950 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15951 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15952 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15953 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15954 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15955 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15956 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15957 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15958 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15959 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15960 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15961 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15962 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15963 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15964 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15965 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15966 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15967 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15968 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15969 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15970 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15971 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15972 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15973 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15974 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15975 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15976 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15977 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15978 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15979 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15980 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15981 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15982 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15983 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15984 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15985 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15986 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15987 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15988 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15989 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15990 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15991 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15992 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15993 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15994 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15995 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15996 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15997 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15998 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15999 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 16000 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 16001 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 16002 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 16003 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 16004 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 16005 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 16006 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 16007 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 16008 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 16009 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 16010 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 16011 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 16012 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 16013 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 16014 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 16015 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 16016 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 16017 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 16018 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 16019 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 16020 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 16021 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 16022 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 16023 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 16024 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 16025 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 16026 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 16027 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 16028 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 16029 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 16030 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 16031 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 16032 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 16033 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 16034 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 16035 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 16036 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 16037 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 16038 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 16039 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 16040 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 16041 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 16042 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 16043 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 16044 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 16045 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 16046 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 16047 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 16048 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 16049 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 16050 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 16051 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 16052 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 16053 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 16054 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 16055 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 16056 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 16057 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 16058 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 16059 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 16060 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 16061 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 16062 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 16063 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 16064 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 16065 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 16066 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 16067 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 16068 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 16069 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 16070 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 16071 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 16072 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 16073 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 16074 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 16075 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 16076 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 16077 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 16078 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 16079 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 16080 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 16081 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 16082 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 16083 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 16084 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 16085 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 16086 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 16087 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 16088 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 16089 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 16090 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 16091 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 16092 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 16093 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 16094 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 16095 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 16096 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 16097 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 16098 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 16099 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 16100 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 16101 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 16102 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 16103 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 16104 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 16105 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 16106 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 16107 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 16108 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 16109 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 16110 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 16111 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 16112 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 16113 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 16114 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 16115 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 16116 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 16117 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 16118 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 16119 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 16120 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 16121 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 16122 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 16123 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 16124 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 16125 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 16126 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 16127 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 16128 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 16129 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 16130 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 16131 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 16132 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 16133 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 16134 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 16135 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 16136 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 16137 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 16138 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 16139 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 16140 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 16141 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 16142 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 16143 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 16144 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 16145 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 16146 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 16147 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 16148 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 16149 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 16150 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 16151 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 16152 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 16153 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 16154 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 16155 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 16156 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 16157 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 16158 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 16159 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 16160 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 16161 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 16162 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 16163 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 16164 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 16165 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 16166 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 16167 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 16168 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 16169 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 16170 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 16171 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 16172 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 16173 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 16174 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 16175 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 16176 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 16177 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 16178 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 16179 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 16180 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 16181 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 16182 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 16183 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 16184 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 16185 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 16186 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 16187 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 16188 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 16189 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 16190 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 16191 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 16192 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 16193 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 16194 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 16195 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 16196 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 16197 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 16198 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 16199 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 16200 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 16201 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 16202 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 16203 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 16204 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 16205 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 16206 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 16207 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 16208 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 16209 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 16210 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 16211 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 16212 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 16213 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 16214 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 16215 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 16216 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 16217 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 16218 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 16219 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 16220 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 16221 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 16222 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 16223 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 16224 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 16225 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 16226 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 16227 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 16228 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 16229 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 16230 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 16231 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 16232 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 16233 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 16234 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 16235 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 16236 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 16237 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 16238 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 16239 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 16240 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 16241 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 16242 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 16243 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 16244 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 16245 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 16246 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 16247 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 16248 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 16249 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 16250 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 16251 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 16252 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 16253 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 16254 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 16255 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 16256 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 16257 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 16258 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 16259 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 16260 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 16261 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 16262 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 16263 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 16264 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 16265 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 16266 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 16267 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 16268 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 16269 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 16270 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 16271 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 16272 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 16273 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 16274 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 16275 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 16276 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 16277 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 16278 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 16279 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 16280 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 16281 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 16282 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 16283 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 16284 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 16285 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 16286 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 16287 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 16288 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 16289 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 16290 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 16291 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 16292 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 16293 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 16294 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 16295 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 16296 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16297 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16298 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16299 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16300 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16301 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16302 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16303 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16304 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16305 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16306 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16307 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16308 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16309 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16310 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16311 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16312 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16313 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16314 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16315 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16316 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16317 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16318 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16319 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16320 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16321 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16322 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16323 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16324 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16325 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16326 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16327 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16328 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16329 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16330 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16331 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16332 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16333 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16334 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16335 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16336 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16337 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16338 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16339 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16340 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16341 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16342 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16343 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16344 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16345 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16346 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16347 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16348 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16349 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16350 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16351 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16352 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16353 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16354 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16355 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16356 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16357 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16358 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16359 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16360 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16361 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16362 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16363 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16364 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16365 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16366 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16367 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16368 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16369 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16370 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16371 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16372 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16373 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16374 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16375 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16376 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16377 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16378 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16379 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16380 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16381 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16382 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16383 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16384 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16385 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16386 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16387 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16388 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16389 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16390 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16391 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16392 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16393 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16394 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16395 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16396 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16397 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16398 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16399 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16400 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16401 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16402 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16403 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16404 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16405 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16406 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16407 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16408 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16409 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16410 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16411 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16412 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16413 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16414 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16415 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16416 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16417 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16418 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16419 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16420 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16421 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16422 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16423 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16424 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16425 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16426 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16427 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16428 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16429 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16430 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16431 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16432 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16433 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16434 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16435 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16436 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16437 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16438 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16439 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16440 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16441 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16442 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16443 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16444 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16445 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16446 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16447 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16448 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16449 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16450 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16451 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16452 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16453 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16454 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16455 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16456 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16457 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16458 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16459 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16460 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16461 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16462 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16463 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16464 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16465 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16466 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16467 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16468 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16469 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16470 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16471 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16472 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16473 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16474 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16475 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16476 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16477 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16478 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16479 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16480 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16481 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16482 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16483 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16484 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16485 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16486 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16487 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16488 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16489 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16490 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16491 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16492 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16493 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16494 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16495 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16496 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16497 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16498 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16499 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16500 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16501 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16502 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16503 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16504 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16505 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16506 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16507 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16508 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16509 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16510 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16511 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16512 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16513 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16514 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16515 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16516 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16517 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16518 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16519 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16520 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16521 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16522 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16523 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16524 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16525 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16526 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16527 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16528 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16529 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16530 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16531 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16532 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16533 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16534 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16535 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16536 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16537 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16538 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16539 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16540 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16541 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16542 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16543 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16544 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16545 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16546 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16547 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16548 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16549 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16550 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16551 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16552 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16553 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16554 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16555 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16556 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16557 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16558 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16559 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16560 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16561 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16562 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16563 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16564 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16565 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16566 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16567 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16568 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16569 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16570 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16571 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16572 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16573 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16574 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16575 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16576 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16577 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16578 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16579 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16580 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16581 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16582 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16583 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16584 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16585 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16586 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16587 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16588 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16589 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16590 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16591 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16592 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16593 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16594 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16595 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16596 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16597 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16598 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16599 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16600 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16601 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16602 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16603 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16604 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16605 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16606 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16607 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16608 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16609 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16610 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16611 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16612 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16613 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16614 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16615 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16616 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16617 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16618 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16619 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16620 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16621 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16622 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16623 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16624 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16625 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16626 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16627 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16628 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16629 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16630 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16631 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16632 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16633 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16634 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16635 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16636 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16637 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16638 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16639 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16640 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16641 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16642 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16643 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16644 "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16645 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16646 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16647 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16648 "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16649 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16650 "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16651 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16652 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+ 16653 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16654 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16655 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16656 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+ 16657 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16658 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16659 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16660 "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16661 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16662 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16663 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16664 "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16665 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16666 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16667 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+ 16668 "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16669 "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+ 16670 "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+ 16671 "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+ 16672 "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+ 16673 "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+ 16674 "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+ 16675 "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+ 16676 "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+ 16677 "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+ 16678 "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+ 16679 "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+ 16680 "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+ 16681 "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+ 16682 "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+ 16683 "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+ 16684 "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+ 16685 "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+ 16686 "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+ 16687 "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+ 16688 "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+ 16689 "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+ 16690 "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+ 16691 "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+ 16692 "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+ 16693 "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+ 16694 "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+ 16695 "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+ 16696 "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e"; 16697 public static final ATN _ATN = 16698 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16699 static { 16700 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16701 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16702 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16703 } 16704 } 16705}