001// Generated from JavadocParser.g4 by ANTLR 4.3 002 003package com.puppycrawl.tools.checkstyle.grammars.javadoc; 004 005import org.antlr.v4.runtime.atn.*; 006import org.antlr.v4.runtime.dfa.DFA; 007import org.antlr.v4.runtime.*; 008import org.antlr.v4.runtime.misc.*; 009import org.antlr.v4.runtime.tree.*; 010import java.util.List; 011import java.util.Iterator; 012import java.util.ArrayList; 013 014@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 015public class JavadocParser extends Parser { 016 static { RuntimeMetaData.checkVersion("4.3", RuntimeMetaData.VERSION); } 017 018 protected static final DFA[] _decisionToDFA; 019 protected static final PredictionContextCache _sharedContextCache = 020 new PredictionContextCache(); 021 public static final int 022 LINK_HTML_TAG_NAME=84, PACKAGE=28, CDATA=3, CLASS=31, MEMBER=33, Char11=88, 023 Char12=90, Char10=54, TBODY_HTML_TAG_NAME=71, CHAR=24, FIELD_TYPE=41, 024 FRAME_HTML_TAG_NAME=79, EQUALS=58, VERSION_LITERAL=18, INHERIT_DOC_LITERAL=47, 025 META_HTML_TAG_NAME=85, JAVADOC_INLINE_TAG_END=20, SERIAL_FIELD_LITERAL=14, 026 Char7=52, COL_HTML_TAG_NAME=78, Char8=53, DOC_ROOT_LITERAL=46, PARAM_HTML_TAG_NAME=86, 027 SINCE_LITERAL=16, RETURN_LITERAL=11, CODE_LITERAL=45, LITERAL_INCLUDE=22, 028 LI_HTML_TAG_NAME=60, SLASH=57, HTML_TAG_NAME=87, Char20=38, COMMA=37, 029 LINK_LITERAL=48, PARAM_LITERAL=10, ARGUMENT=36, TH_HTML_TAG_NAME=63, BASEFRONT_HTML_TAG_NAME=76, 030 THROWS_LITERAL=17, VALUE_LITERAL=51, EXCEPTION_LITERAL=9, INPUT_HTML_TAG_NAME=82, 031 DOT=29, SERIAL_LITERAL=13, TD_HTML_TAG_NAME=62, RIGHT_BRACE=35, DD_HTML_TAG_NAME=66, 032 FIELD_NAME=39, HTML_COMMENT_START=2, CLASS_NAME=43, PARAMETER_NAME=25, 033 TFOOT_HTML_TAG_NAME=72, ISINDEX_HTML_TAG_NAME=83, AUTHOR_LITERAL=7, JAVADOC_INLINE_TAG_START=19, 034 HASH=30, LEADING_ASTERISK=1, CUSTOM_NAME=21, HTML_COMMENT_END=91, LINKPLAIN_LITERAL=49, 035 LITERAL_EXCLUDE=23, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, BODY_HTML_TAG_NAME=64, 036 HR_HTML_TAG_NAME=80, DT_HTML_TAG_NAME=67, OPEN=5, WS=4, NEWLINE=6, CLOSE=55, 037 Char4=42, SEE_LITERAL=12, Char5=44, TR_HTML_TAG_NAME=61, Char2=32, HEAD_HTML_TAG_NAME=68, 038 LEFT_BRACE=34, Char3=40, OPTION_HTML_TAG_NAME=70, BASE_HTML_TAG_NAME=75, 039 Char1=26, IMG_HTML_TAG_NAME=81, LITERAL_LITERAL=50, ATTR_VALUE=89, HTML_HTML_TAG_NAME=69, 040 SLASH_CLOSE=56, P_HTML_TAG_NAME=59, COLGROUP_HTML_TAG_NAME=65, SERIAL_DATA_LITERAL=15, 041 BR_HTML_TAG_NAME=77, DEPRECATED_LITERAL=8, STRING=27; 042 public static final String[] tokenNames = { 043 "<INVALID>", "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", 044 "OPEN", "'\n'", "'@author'", "'@deprecated'", "EXCEPTION_LITERAL", "PARAM_LITERAL", 045 "'@return'", "SEE_LITERAL", "'@serial'", "SERIAL_FIELD_LITERAL", "'@serialData'", 046 "'@since'", "THROWS_LITERAL", "'@version'", "JAVADOC_INLINE_TAG_START", 047 "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "'include'", "'exclude'", "CHAR", 048 "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", "'.'", "HASH", "CLASS", 049 "Char2", "MEMBER", "'('", "')'", "ARGUMENT", "','", "Char20", "FIELD_NAME", 050 "Char3", "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", 051 "'@docRoot'", "'@inheritDoc'", "'@link'", "'@linkplain'", "LITERAL_LITERAL", 052 "'@value'", "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "'/'", 053 "'='", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 054 "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 055 "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 056 "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 057 "BASE_HTML_TAG_NAME", "BASEFRONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 058 "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 059 "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 060 "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "'-->'" 061 }; 062 public static final int 063 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 064 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 065 RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 066 RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 067 RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 068 RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 069 RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 070 RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 071 RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 072 RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 073 RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 074 RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 075 RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 076 RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 077 RULE_baseTag = 54, RULE_basefrontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 078 RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 079 RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 080 RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 081 RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 082 RULE_htmlComment = 73, RULE_text = 74; 083 public static final String[] ruleNames = { 084 "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 085 "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 086 "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 087 "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 088 "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 089 "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 090 "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 091 "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 092 "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 093 "singletonTag", "areaTag", "baseTag", "basefrontTag", "brTag", "colTag", 094 "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 095 "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 096 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text" 097 }; 098 099 @Override 100 public String getGrammarFileName() { return "JavadocParser.g4"; } 101 102 @Override 103 public String[] getTokenNames() { return tokenNames; } 104 105 @Override 106 public String[] getRuleNames() { return ruleNames; } 107 108 @Override 109 public String getSerializedATN() { return _serializedATN; } 110 111 @Override 112 public ATN getATN() { return _ATN; } 113 114 115 boolean isNextJavadocTag() { 116 int token1 = _input.LA(2); 117 int token2 = _input.LA(3); 118 return isJavadocTag(token1) 119 || (token1 == WS && isJavadocTag(token2)); 120 } 121 122 boolean isJavadocTag(int type) { 123 switch(type) { 124 case AUTHOR_LITERAL: 125 case DEPRECATED_LITERAL: 126 case EXCEPTION_LITERAL: 127 case PARAM_LITERAL: 128 case RETURN_LITERAL: 129 case SEE_LITERAL: 130 case SERIAL_LITERAL: 131 case SERIAL_FIELD_LITERAL: 132 case SERIAL_DATA_LITERAL: 133 case SINCE_LITERAL: 134 case THROWS_LITERAL: 135 case VERSION_LITERAL: 136 case CUSTOM_NAME: 137 return true; 138 default: 139 return false; 140 } 141 } 142 143 boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) { 144 String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 145 String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 146 System.out.println(openTag + " - " + closeTag); 147 return openTag.equals(closeTag); 148 } 149 150 public JavadocParser(TokenStream input) { 151 super(input); 152 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 153 } 154 public static class JavadocContext extends ParserRuleContext { 155 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 156 public JavadocTagContext javadocTag(int i) { 157 return getRuleContext(JavadocTagContext.class,i); 158 } 159 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 160 public TerminalNode NEWLINE(int i) { 161 return getToken(JavadocParser.NEWLINE, i); 162 } 163 public List<HtmlElementContext> htmlElement() { 164 return getRuleContexts(HtmlElementContext.class); 165 } 166 public TextContext text(int i) { 167 return getRuleContext(TextContext.class,i); 168 } 169 public List<JavadocInlineTagContext> javadocInlineTag() { 170 return getRuleContexts(JavadocInlineTagContext.class); 171 } 172 public List<HtmlCommentContext> htmlComment() { 173 return getRuleContexts(HtmlCommentContext.class); 174 } 175 public TerminalNode CDATA(int i) { 176 return getToken(JavadocParser.CDATA, i); 177 } 178 public TerminalNode WS(int i) { 179 return getToken(JavadocParser.WS, i); 180 } 181 public HtmlCommentContext htmlComment(int i) { 182 return getRuleContext(HtmlCommentContext.class,i); 183 } 184 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 185 public List<TextContext> text() { 186 return getRuleContexts(TextContext.class); 187 } 188 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 189 public HtmlElementContext htmlElement(int i) { 190 return getRuleContext(HtmlElementContext.class,i); 191 } 192 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 193 public List<JavadocTagContext> javadocTag() { 194 return getRuleContexts(JavadocTagContext.class); 195 } 196 public JavadocInlineTagContext javadocInlineTag(int i) { 197 return getRuleContext(JavadocInlineTagContext.class,i); 198 } 199 public TerminalNode LEADING_ASTERISK(int i) { 200 return getToken(JavadocParser.LEADING_ASTERISK, i); 201 } 202 public JavadocContext(ParserRuleContext parent, int invokingState) { 203 super(parent, invokingState); 204 } 205 @Override public int getRuleIndex() { return RULE_javadoc; } 206 @Override 207 public void enterRule(ParseTreeListener listener) { 208 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this); 209 } 210 @Override 211 public void exitRule(ParseTreeListener listener) { 212 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this); 213 } 214 @Override 215 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 216 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); 217 else return visitor.visitChildren(this); 218 } 219 } 220 221 public final JavadocContext javadoc() throws RecognitionException { 222 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 223 enterRule(_localctx, 0, RULE_javadoc); 224 int _la; 225 try { 226 int _alt; 227 enterOuterAlt(_localctx, 1); 228 { 229 setState(160); 230 _errHandler.sync(this); 231 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 232 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 233 if ( _alt==1 ) { 234 { 235 setState(158); 236 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 237 case 1: 238 { 239 setState(150); htmlElement(); 240 } 241 break; 242 243 case 2: 244 { 245 { 246 setState(151); 247 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 248 setState(152); match(LEADING_ASTERISK); 249 } 250 } 251 break; 252 253 case 3: 254 { 255 setState(153); htmlComment(); 256 } 257 break; 258 259 case 4: 260 { 261 setState(154); match(CDATA); 262 } 263 break; 264 265 case 5: 266 { 267 setState(155); match(NEWLINE); 268 } 269 break; 270 271 case 6: 272 { 273 setState(156); text(); 274 } 275 break; 276 277 case 7: 278 { 279 setState(157); javadocInlineTag(); 280 } 281 break; 282 } 283 } 284 } 285 setState(162); 286 _errHandler.sync(this); 287 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 288 } 289 setState(175); 290 _errHandler.sync(this); 291 _la = _input.LA(1); 292 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)) { 293 { 294 { 295 setState(164); 296 _la = _input.LA(1); 297 if (_la==LEADING_ASTERISK) { 298 { 299 setState(163); match(LEADING_ASTERISK); 300 } 301 } 302 303 setState(169); 304 _errHandler.sync(this); 305 _la = _input.LA(1); 306 while (_la==WS) { 307 { 308 { 309 setState(166); match(WS); 310 } 311 } 312 setState(171); 313 _errHandler.sync(this); 314 _la = _input.LA(1); 315 } 316 setState(172); javadocTag(); 317 } 318 } 319 setState(177); 320 _errHandler.sync(this); 321 _la = _input.LA(1); 322 } 323 setState(178); match(EOF); 324 } 325 } 326 catch (RecognitionException re) { 327 _localctx.exception = re; 328 _errHandler.reportError(this, re); 329 _errHandler.recover(this, re); 330 } 331 finally { 332 exitRule(); 333 } 334 return _localctx; 335 } 336 337 public static class HtmlElementContext extends ParserRuleContext { 338 public TheadTagCloseContext theadTagClose() { 339 return getRuleContext(TheadTagCloseContext.class,0); 340 } 341 public ColgroupTagOpenContext colgroupTagOpen() { 342 return getRuleContext(ColgroupTagOpenContext.class,0); 343 } 344 public TbodyTagCloseContext tbodyTagClose() { 345 return getRuleContext(TbodyTagCloseContext.class,0); 346 } 347 public ThTagCloseContext thTagClose() { 348 return getRuleContext(ThTagCloseContext.class,0); 349 } 350 public PTagCloseContext pTagClose() { 351 return getRuleContext(PTagCloseContext.class,0); 352 } 353 public HtmlTagCloseContext htmlTagClose() { 354 return getRuleContext(HtmlTagCloseContext.class,0); 355 } 356 public ParagraphContext paragraph() { 357 return getRuleContext(ParagraphContext.class,0); 358 } 359 public DdTagCloseContext ddTagClose() { 360 return getRuleContext(DdTagCloseContext.class,0); 361 } 362 public DtTagOpenContext dtTagOpen() { 363 return getRuleContext(DtTagOpenContext.class,0); 364 } 365 public ColgroupContext colgroup() { 366 return getRuleContext(ColgroupContext.class,0); 367 } 368 public TrContext tr() { 369 return getRuleContext(TrContext.class,0); 370 } 371 public LiContext li() { 372 return getRuleContext(LiContext.class,0); 373 } 374 public HtmlContext html() { 375 return getRuleContext(HtmlContext.class,0); 376 } 377 public ThContext th() { 378 return getRuleContext(ThContext.class,0); 379 } 380 public DdTagOpenContext ddTagOpen() { 381 return getRuleContext(DdTagOpenContext.class,0); 382 } 383 public HeadTagCloseContext headTagClose() { 384 return getRuleContext(HeadTagCloseContext.class,0); 385 } 386 public ThTagOpenContext thTagOpen() { 387 return getRuleContext(ThTagOpenContext.class,0); 388 } 389 public HeadTagOpenContext headTagOpen() { 390 return getRuleContext(HeadTagOpenContext.class,0); 391 } 392 public HtmlTagOpenContext htmlTagOpen() { 393 return getRuleContext(HtmlTagOpenContext.class,0); 394 } 395 public TrTagOpenContext trTagOpen() { 396 return getRuleContext(TrTagOpenContext.class,0); 397 } 398 public TbodyTagOpenContext tbodyTagOpen() { 399 return getRuleContext(TbodyTagOpenContext.class,0); 400 } 401 public TbodyContext tbody() { 402 return getRuleContext(TbodyContext.class,0); 403 } 404 public TheadContext thead() { 405 return getRuleContext(TheadContext.class,0); 406 } 407 public TheadTagOpenContext theadTagOpen() { 408 return getRuleContext(TheadTagOpenContext.class,0); 409 } 410 public HeadContext head() { 411 return getRuleContext(HeadContext.class,0); 412 } 413 public TfootTagOpenContext tfootTagOpen() { 414 return getRuleContext(TfootTagOpenContext.class,0); 415 } 416 public TfootContext tfoot() { 417 return getRuleContext(TfootContext.class,0); 418 } 419 public LiTagCloseContext liTagClose() { 420 return getRuleContext(LiTagCloseContext.class,0); 421 } 422 public BodyContext body() { 423 return getRuleContext(BodyContext.class,0); 424 } 425 public BodyTagCloseContext bodyTagClose() { 426 return getRuleContext(BodyTagCloseContext.class,0); 427 } 428 public OptionTagOpenContext optionTagOpen() { 429 return getRuleContext(OptionTagOpenContext.class,0); 430 } 431 public TfootTagCloseContext tfootTagClose() { 432 return getRuleContext(TfootTagCloseContext.class,0); 433 } 434 public DtContext dt() { 435 return getRuleContext(DtContext.class,0); 436 } 437 public DdContext dd() { 438 return getRuleContext(DdContext.class,0); 439 } 440 public TdContext td() { 441 return getRuleContext(TdContext.class,0); 442 } 443 public BodyTagOpenContext bodyTagOpen() { 444 return getRuleContext(BodyTagOpenContext.class,0); 445 } 446 public ColgroupTagCloseContext colgroupTagClose() { 447 return getRuleContext(ColgroupTagCloseContext.class,0); 448 } 449 public TdTagCloseContext tdTagClose() { 450 return getRuleContext(TdTagCloseContext.class,0); 451 } 452 public SingletonElementContext singletonElement() { 453 return getRuleContext(SingletonElementContext.class,0); 454 } 455 public LiTagOpenContext liTagOpen() { 456 return getRuleContext(LiTagOpenContext.class,0); 457 } 458 public OptionContext option() { 459 return getRuleContext(OptionContext.class,0); 460 } 461 public PTagOpenContext pTagOpen() { 462 return getRuleContext(PTagOpenContext.class,0); 463 } 464 public DtTagCloseContext dtTagClose() { 465 return getRuleContext(DtTagCloseContext.class,0); 466 } 467 public TrTagCloseContext trTagClose() { 468 return getRuleContext(TrTagCloseContext.class,0); 469 } 470 public OptionTagCloseContext optionTagClose() { 471 return getRuleContext(OptionTagCloseContext.class,0); 472 } 473 public HtmlTagContext htmlTag() { 474 return getRuleContext(HtmlTagContext.class,0); 475 } 476 public TdTagOpenContext tdTagOpen() { 477 return getRuleContext(TdTagOpenContext.class,0); 478 } 479 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 480 super(parent, invokingState); 481 } 482 @Override public int getRuleIndex() { return RULE_htmlElement; } 483 @Override 484 public void enterRule(ParseTreeListener listener) { 485 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 486 } 487 @Override 488 public void exitRule(ParseTreeListener listener) { 489 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 490 } 491 @Override 492 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 493 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 494 else return visitor.visitChildren(this); 495 } 496 } 497 498 public final HtmlElementContext htmlElement() throws RecognitionException { 499 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 500 enterRule(_localctx, 2, RULE_htmlElement); 501 try { 502 setState(227); 503 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 504 case 1: 505 enterOuterAlt(_localctx, 1); 506 { 507 setState(180); htmlTag(); 508 } 509 break; 510 511 case 2: 512 enterOuterAlt(_localctx, 2); 513 { 514 setState(181); singletonElement(); 515 } 516 break; 517 518 case 3: 519 enterOuterAlt(_localctx, 3); 520 { 521 setState(182); paragraph(); 522 } 523 break; 524 525 case 4: 526 enterOuterAlt(_localctx, 4); 527 { 528 setState(183); li(); 529 } 530 break; 531 532 case 5: 533 enterOuterAlt(_localctx, 5); 534 { 535 setState(184); tr(); 536 } 537 break; 538 539 case 6: 540 enterOuterAlt(_localctx, 6); 541 { 542 setState(185); td(); 543 } 544 break; 545 546 case 7: 547 enterOuterAlt(_localctx, 7); 548 { 549 setState(186); th(); 550 } 551 break; 552 553 case 8: 554 enterOuterAlt(_localctx, 8); 555 { 556 setState(187); body(); 557 } 558 break; 559 560 case 9: 561 enterOuterAlt(_localctx, 9); 562 { 563 setState(188); colgroup(); 564 } 565 break; 566 567 case 10: 568 enterOuterAlt(_localctx, 10); 569 { 570 setState(189); dd(); 571 } 572 break; 573 574 case 11: 575 enterOuterAlt(_localctx, 11); 576 { 577 setState(190); dt(); 578 } 579 break; 580 581 case 12: 582 enterOuterAlt(_localctx, 12); 583 { 584 setState(191); head(); 585 } 586 break; 587 588 case 13: 589 enterOuterAlt(_localctx, 13); 590 { 591 setState(192); html(); 592 } 593 break; 594 595 case 14: 596 enterOuterAlt(_localctx, 14); 597 { 598 setState(193); option(); 599 } 600 break; 601 602 case 15: 603 enterOuterAlt(_localctx, 15); 604 { 605 setState(194); tbody(); 606 } 607 break; 608 609 case 16: 610 enterOuterAlt(_localctx, 16); 611 { 612 setState(195); thead(); 613 } 614 break; 615 616 case 17: 617 enterOuterAlt(_localctx, 17); 618 { 619 setState(196); tfoot(); 620 } 621 break; 622 623 case 18: 624 enterOuterAlt(_localctx, 18); 625 { 626 setState(197); pTagOpen(); 627 } 628 break; 629 630 case 19: 631 enterOuterAlt(_localctx, 19); 632 { 633 setState(198); liTagOpen(); 634 } 635 break; 636 637 case 20: 638 enterOuterAlt(_localctx, 20); 639 { 640 setState(199); trTagOpen(); 641 } 642 break; 643 644 case 21: 645 enterOuterAlt(_localctx, 21); 646 { 647 setState(200); tdTagOpen(); 648 } 649 break; 650 651 case 22: 652 enterOuterAlt(_localctx, 22); 653 { 654 setState(201); thTagOpen(); 655 } 656 break; 657 658 case 23: 659 enterOuterAlt(_localctx, 23); 660 { 661 setState(202); bodyTagOpen(); 662 } 663 break; 664 665 case 24: 666 enterOuterAlt(_localctx, 24); 667 { 668 setState(203); colgroupTagOpen(); 669 } 670 break; 671 672 case 25: 673 enterOuterAlt(_localctx, 25); 674 { 675 setState(204); ddTagOpen(); 676 } 677 break; 678 679 case 26: 680 enterOuterAlt(_localctx, 26); 681 { 682 setState(205); dtTagOpen(); 683 } 684 break; 685 686 case 27: 687 enterOuterAlt(_localctx, 27); 688 { 689 setState(206); headTagOpen(); 690 } 691 break; 692 693 case 28: 694 enterOuterAlt(_localctx, 28); 695 { 696 setState(207); htmlTagOpen(); 697 } 698 break; 699 700 case 29: 701 enterOuterAlt(_localctx, 29); 702 { 703 setState(208); optionTagOpen(); 704 } 705 break; 706 707 case 30: 708 enterOuterAlt(_localctx, 30); 709 { 710 setState(209); tbodyTagOpen(); 711 } 712 break; 713 714 case 31: 715 enterOuterAlt(_localctx, 31); 716 { 717 setState(210); theadTagOpen(); 718 } 719 break; 720 721 case 32: 722 enterOuterAlt(_localctx, 32); 723 { 724 setState(211); tfootTagOpen(); 725 } 726 break; 727 728 case 33: 729 enterOuterAlt(_localctx, 33); 730 { 731 setState(212); pTagClose(); 732 } 733 break; 734 735 case 34: 736 enterOuterAlt(_localctx, 34); 737 { 738 setState(213); liTagClose(); 739 } 740 break; 741 742 case 35: 743 enterOuterAlt(_localctx, 35); 744 { 745 setState(214); trTagClose(); 746 } 747 break; 748 749 case 36: 750 enterOuterAlt(_localctx, 36); 751 { 752 setState(215); tdTagClose(); 753 } 754 break; 755 756 case 37: 757 enterOuterAlt(_localctx, 37); 758 { 759 setState(216); thTagClose(); 760 } 761 break; 762 763 case 38: 764 enterOuterAlt(_localctx, 38); 765 { 766 setState(217); bodyTagClose(); 767 } 768 break; 769 770 case 39: 771 enterOuterAlt(_localctx, 39); 772 { 773 setState(218); colgroupTagClose(); 774 } 775 break; 776 777 case 40: 778 enterOuterAlt(_localctx, 40); 779 { 780 setState(219); ddTagClose(); 781 } 782 break; 783 784 case 41: 785 enterOuterAlt(_localctx, 41); 786 { 787 setState(220); dtTagClose(); 788 } 789 break; 790 791 case 42: 792 enterOuterAlt(_localctx, 42); 793 { 794 setState(221); headTagClose(); 795 } 796 break; 797 798 case 43: 799 enterOuterAlt(_localctx, 43); 800 { 801 setState(222); htmlTagClose(); 802 } 803 break; 804 805 case 44: 806 enterOuterAlt(_localctx, 44); 807 { 808 setState(223); optionTagClose(); 809 } 810 break; 811 812 case 45: 813 enterOuterAlt(_localctx, 45); 814 { 815 setState(224); tbodyTagClose(); 816 } 817 break; 818 819 case 46: 820 enterOuterAlt(_localctx, 46); 821 { 822 setState(225); theadTagClose(); 823 } 824 break; 825 826 case 47: 827 enterOuterAlt(_localctx, 47); 828 { 829 setState(226); tfootTagClose(); 830 } 831 break; 832 } 833 } 834 catch (RecognitionException re) { 835 _localctx.exception = re; 836 _errHandler.reportError(this, re); 837 _errHandler.recover(this, re); 838 } 839 finally { 840 exitRule(); 841 } 842 return _localctx; 843 } 844 845 public static class HtmlElementOpenContext extends ParserRuleContext { 846 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 847 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 848 public TerminalNode NEWLINE(int i) { 849 return getToken(JavadocParser.NEWLINE, i); 850 } 851 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 852 public List<AttributeContext> attribute() { 853 return getRuleContexts(AttributeContext.class); 854 } 855 public AttributeContext attribute(int i) { 856 return getRuleContext(AttributeContext.class,i); 857 } 858 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 859 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 860 public TerminalNode LEADING_ASTERISK(int i) { 861 return getToken(JavadocParser.LEADING_ASTERISK, i); 862 } 863 public TerminalNode WS(int i) { 864 return getToken(JavadocParser.WS, i); 865 } 866 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 867 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 868 super(parent, invokingState); 869 } 870 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 871 @Override 872 public void enterRule(ParseTreeListener listener) { 873 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 874 } 875 @Override 876 public void exitRule(ParseTreeListener listener) { 877 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 878 } 879 @Override 880 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 881 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 882 else return visitor.visitChildren(this); 883 } 884 } 885 886 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 887 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 888 enterRule(_localctx, 4, RULE_htmlElementOpen); 889 int _la; 890 try { 891 enterOuterAlt(_localctx, 1); 892 { 893 setState(229); match(OPEN); 894 setState(230); match(HTML_TAG_NAME); 895 setState(237); 896 _errHandler.sync(this); 897 _la = _input.LA(1); 898 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 899 { 900 setState(235); 901 switch (_input.LA(1)) { 902 case HTML_TAG_NAME: 903 { 904 setState(231); attribute(); 905 } 906 break; 907 case NEWLINE: 908 { 909 setState(232); match(NEWLINE); 910 } 911 break; 912 case LEADING_ASTERISK: 913 { 914 setState(233); match(LEADING_ASTERISK); 915 } 916 break; 917 case WS: 918 { 919 setState(234); match(WS); 920 } 921 break; 922 default: 923 throw new NoViableAltException(this); 924 } 925 } 926 setState(239); 927 _errHandler.sync(this); 928 _la = _input.LA(1); 929 } 930 setState(240); match(CLOSE); 931 } 932 } 933 catch (RecognitionException re) { 934 _localctx.exception = re; 935 _errHandler.reportError(this, re); 936 _errHandler.recover(this, re); 937 } 938 finally { 939 exitRule(); 940 } 941 return _localctx; 942 } 943 944 public static class HtmlElementCloseContext extends ParserRuleContext { 945 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 946 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 947 public TerminalNode NEWLINE(int i) { 948 return getToken(JavadocParser.NEWLINE, i); 949 } 950 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 951 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 952 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 953 public TerminalNode LEADING_ASTERISK(int i) { 954 return getToken(JavadocParser.LEADING_ASTERISK, i); 955 } 956 public TerminalNode WS(int i) { 957 return getToken(JavadocParser.WS, i); 958 } 959 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 960 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 961 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 962 super(parent, invokingState); 963 } 964 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 965 @Override 966 public void enterRule(ParseTreeListener listener) { 967 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 968 } 969 @Override 970 public void exitRule(ParseTreeListener listener) { 971 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 972 } 973 @Override 974 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 975 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 976 else return visitor.visitChildren(this); 977 } 978 } 979 980 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 981 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 982 enterRule(_localctx, 6, RULE_htmlElementClose); 983 int _la; 984 try { 985 enterOuterAlt(_localctx, 1); 986 { 987 setState(242); match(OPEN); 988 setState(243); match(SLASH); 989 setState(244); match(HTML_TAG_NAME); 990 setState(248); 991 _errHandler.sync(this); 992 _la = _input.LA(1); 993 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 994 { 995 { 996 setState(245); 997 _la = _input.LA(1); 998 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 999 _errHandler.recoverInline(this); 1000 } 1001 consume(); 1002 } 1003 } 1004 setState(250); 1005 _errHandler.sync(this); 1006 _la = _input.LA(1); 1007 } 1008 setState(251); match(CLOSE); 1009 } 1010 } 1011 catch (RecognitionException re) { 1012 _localctx.exception = re; 1013 _errHandler.reportError(this, re); 1014 _errHandler.recover(this, re); 1015 } 1016 finally { 1017 exitRule(); 1018 } 1019 return _localctx; 1020 } 1021 1022 public static class AttributeContext extends ParserRuleContext { 1023 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1024 public TextContext text() { 1025 return getRuleContext(TextContext.class,0); 1026 } 1027 public TerminalNode HTML_TAG_NAME(int i) { 1028 return getToken(JavadocParser.HTML_TAG_NAME, i); 1029 } 1030 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1031 public TerminalNode NEWLINE(int i) { 1032 return getToken(JavadocParser.NEWLINE, i); 1033 } 1034 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1035 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1036 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1037 public TerminalNode LEADING_ASTERISK(int i) { 1038 return getToken(JavadocParser.LEADING_ASTERISK, i); 1039 } 1040 public TerminalNode WS(int i) { 1041 return getToken(JavadocParser.WS, i); 1042 } 1043 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1044 public AttributeContext(ParserRuleContext parent, int invokingState) { 1045 super(parent, invokingState); 1046 } 1047 @Override public int getRuleIndex() { return RULE_attribute; } 1048 @Override 1049 public void enterRule(ParseTreeListener listener) { 1050 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1051 } 1052 @Override 1053 public void exitRule(ParseTreeListener listener) { 1054 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1055 } 1056 @Override 1057 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1058 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1059 else return visitor.visitChildren(this); 1060 } 1061 } 1062 1063 public final AttributeContext attribute() throws RecognitionException { 1064 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1065 enterRule(_localctx, 8, RULE_attribute); 1066 int _la; 1067 try { 1068 int _alt; 1069 enterOuterAlt(_localctx, 1); 1070 { 1071 setState(253); match(HTML_TAG_NAME); 1072 setState(257); 1073 _errHandler.sync(this); 1074 _la = _input.LA(1); 1075 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1076 { 1077 { 1078 setState(254); 1079 _la = _input.LA(1); 1080 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1081 _errHandler.recoverInline(this); 1082 } 1083 consume(); 1084 } 1085 } 1086 setState(259); 1087 _errHandler.sync(this); 1088 _la = _input.LA(1); 1089 } 1090 setState(260); match(EQUALS); 1091 setState(264); 1092 _errHandler.sync(this); 1093 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1094 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1095 if ( _alt==1 ) { 1096 { 1097 { 1098 setState(261); 1099 _la = _input.LA(1); 1100 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1101 _errHandler.recoverInline(this); 1102 } 1103 consume(); 1104 } 1105 } 1106 } 1107 setState(266); 1108 _errHandler.sync(this); 1109 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1110 } 1111 setState(270); 1112 switch (_input.LA(1)) { 1113 case ATTR_VALUE: 1114 { 1115 setState(267); match(ATTR_VALUE); 1116 } 1117 break; 1118 case WS: 1119 case CHAR: 1120 { 1121 setState(268); text(); 1122 } 1123 break; 1124 case HTML_TAG_NAME: 1125 { 1126 setState(269); match(HTML_TAG_NAME); 1127 } 1128 break; 1129 default: 1130 throw new NoViableAltException(this); 1131 } 1132 } 1133 } 1134 catch (RecognitionException re) { 1135 _localctx.exception = re; 1136 _errHandler.reportError(this, re); 1137 _errHandler.recover(this, re); 1138 } 1139 finally { 1140 exitRule(); 1141 } 1142 return _localctx; 1143 } 1144 1145 public static class HtmlTagContext extends ParserRuleContext { 1146 public HtmlElementOpenContext htmlElementOpen; 1147 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1148 public TerminalNode NEWLINE(int i) { 1149 return getToken(JavadocParser.NEWLINE, i); 1150 } 1151 public List<JavadocInlineTagContext> javadocInlineTag() { 1152 return getRuleContexts(JavadocInlineTagContext.class); 1153 } 1154 public List<HtmlElementContext> htmlElement() { 1155 return getRuleContexts(HtmlElementContext.class); 1156 } 1157 public TextContext text(int i) { 1158 return getRuleContext(TextContext.class,i); 1159 } 1160 public List<HtmlCommentContext> htmlComment() { 1161 return getRuleContexts(HtmlCommentContext.class); 1162 } 1163 public TerminalNode CDATA(int i) { 1164 return getToken(JavadocParser.CDATA, i); 1165 } 1166 public HtmlCommentContext htmlComment(int i) { 1167 return getRuleContext(HtmlCommentContext.class,i); 1168 } 1169 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1170 public List<TextContext> text() { 1171 return getRuleContexts(TextContext.class); 1172 } 1173 public HtmlElementContext htmlElement(int i) { 1174 return getRuleContext(HtmlElementContext.class,i); 1175 } 1176 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1177 public HtmlElementOpenContext htmlElementOpen() { 1178 return getRuleContext(HtmlElementOpenContext.class,0); 1179 } 1180 public JavadocInlineTagContext javadocInlineTag(int i) { 1181 return getRuleContext(JavadocInlineTagContext.class,i); 1182 } 1183 public HtmlElementCloseContext htmlElementClose() { 1184 return getRuleContext(HtmlElementCloseContext.class,0); 1185 } 1186 public TerminalNode LEADING_ASTERISK(int i) { 1187 return getToken(JavadocParser.LEADING_ASTERISK, i); 1188 } 1189 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1190 super(parent, invokingState); 1191 } 1192 @Override public int getRuleIndex() { return RULE_htmlTag; } 1193 @Override 1194 public void enterRule(ParseTreeListener listener) { 1195 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1196 } 1197 @Override 1198 public void exitRule(ParseTreeListener listener) { 1199 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1200 } 1201 @Override 1202 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1203 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1204 else return visitor.visitChildren(this); 1205 } 1206 } 1207 1208 public final HtmlTagContext htmlTag() throws RecognitionException { 1209 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1210 enterRule(_localctx, 10, RULE_htmlTag); 1211 try { 1212 int _alt; 1213 setState(304); 1214 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1215 case 1: 1216 enterOuterAlt(_localctx, 1); 1217 { 1218 setState(272); htmlElementOpen(); 1219 setState(283); 1220 _errHandler.sync(this); 1221 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1222 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1223 if ( _alt==1 ) { 1224 { 1225 setState(281); 1226 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1227 case 1: 1228 { 1229 setState(273); htmlElement(); 1230 } 1231 break; 1232 1233 case 2: 1234 { 1235 { 1236 setState(274); 1237 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1238 setState(275); match(LEADING_ASTERISK); 1239 } 1240 } 1241 break; 1242 1243 case 3: 1244 { 1245 setState(276); htmlComment(); 1246 } 1247 break; 1248 1249 case 4: 1250 { 1251 setState(277); match(CDATA); 1252 } 1253 break; 1254 1255 case 5: 1256 { 1257 setState(278); match(NEWLINE); 1258 } 1259 break; 1260 1261 case 6: 1262 { 1263 setState(279); text(); 1264 } 1265 break; 1266 1267 case 7: 1268 { 1269 setState(280); javadocInlineTag(); 1270 } 1271 break; 1272 } 1273 } 1274 } 1275 setState(285); 1276 _errHandler.sync(this); 1277 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1278 } 1279 setState(286); htmlElementClose(); 1280 } 1281 break; 1282 1283 case 2: 1284 enterOuterAlt(_localctx, 2); 1285 { 1286 setState(288); ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1287 setState(299); 1288 _errHandler.sync(this); 1289 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1290 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1291 if ( _alt==1 ) { 1292 { 1293 setState(297); 1294 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1295 case 1: 1296 { 1297 setState(289); htmlElement(); 1298 } 1299 break; 1300 1301 case 2: 1302 { 1303 { 1304 setState(290); 1305 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1306 setState(291); match(LEADING_ASTERISK); 1307 } 1308 } 1309 break; 1310 1311 case 3: 1312 { 1313 setState(292); htmlComment(); 1314 } 1315 break; 1316 1317 case 4: 1318 { 1319 setState(293); match(CDATA); 1320 } 1321 break; 1322 1323 case 5: 1324 { 1325 setState(294); match(NEWLINE); 1326 } 1327 break; 1328 1329 case 6: 1330 { 1331 setState(295); text(); 1332 } 1333 break; 1334 1335 case 7: 1336 { 1337 setState(296); javadocInlineTag(); 1338 } 1339 break; 1340 } 1341 } 1342 } 1343 setState(301); 1344 _errHandler.sync(this); 1345 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1346 } 1347 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol(), "javadoc.missed.html.close", null); 1348 } 1349 break; 1350 } 1351 } 1352 catch (RecognitionException re) { 1353 _localctx.exception = re; 1354 _errHandler.reportError(this, re); 1355 _errHandler.recover(this, re); 1356 } 1357 finally { 1358 exitRule(); 1359 } 1360 return _localctx; 1361 } 1362 1363 public static class PTagOpenContext extends ParserRuleContext { 1364 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1365 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1366 public TerminalNode NEWLINE(int i) { 1367 return getToken(JavadocParser.NEWLINE, i); 1368 } 1369 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1370 public List<AttributeContext> attribute() { 1371 return getRuleContexts(AttributeContext.class); 1372 } 1373 public AttributeContext attribute(int i) { 1374 return getRuleContext(AttributeContext.class,i); 1375 } 1376 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1377 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1378 public TerminalNode LEADING_ASTERISK(int i) { 1379 return getToken(JavadocParser.LEADING_ASTERISK, i); 1380 } 1381 public TerminalNode WS(int i) { 1382 return getToken(JavadocParser.WS, i); 1383 } 1384 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1385 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1386 super(parent, invokingState); 1387 } 1388 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1389 @Override 1390 public void enterRule(ParseTreeListener listener) { 1391 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1392 } 1393 @Override 1394 public void exitRule(ParseTreeListener listener) { 1395 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1396 } 1397 @Override 1398 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1399 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1400 else return visitor.visitChildren(this); 1401 } 1402 } 1403 1404 public final PTagOpenContext pTagOpen() throws RecognitionException { 1405 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1406 enterRule(_localctx, 12, RULE_pTagOpen); 1407 int _la; 1408 try { 1409 enterOuterAlt(_localctx, 1); 1410 { 1411 setState(306); match(OPEN); 1412 setState(307); match(P_HTML_TAG_NAME); 1413 setState(314); 1414 _errHandler.sync(this); 1415 _la = _input.LA(1); 1416 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1417 { 1418 setState(312); 1419 switch (_input.LA(1)) { 1420 case HTML_TAG_NAME: 1421 { 1422 setState(308); attribute(); 1423 } 1424 break; 1425 case NEWLINE: 1426 { 1427 setState(309); match(NEWLINE); 1428 } 1429 break; 1430 case LEADING_ASTERISK: 1431 { 1432 setState(310); match(LEADING_ASTERISK); 1433 } 1434 break; 1435 case WS: 1436 { 1437 setState(311); match(WS); 1438 } 1439 break; 1440 default: 1441 throw new NoViableAltException(this); 1442 } 1443 } 1444 setState(316); 1445 _errHandler.sync(this); 1446 _la = _input.LA(1); 1447 } 1448 setState(317); match(CLOSE); 1449 } 1450 } 1451 catch (RecognitionException re) { 1452 _localctx.exception = re; 1453 _errHandler.reportError(this, re); 1454 _errHandler.recover(this, re); 1455 } 1456 finally { 1457 exitRule(); 1458 } 1459 return _localctx; 1460 } 1461 1462 public static class PTagCloseContext extends ParserRuleContext { 1463 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1464 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1465 public TerminalNode NEWLINE(int i) { 1466 return getToken(JavadocParser.NEWLINE, i); 1467 } 1468 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1469 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1470 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1471 public TerminalNode LEADING_ASTERISK(int i) { 1472 return getToken(JavadocParser.LEADING_ASTERISK, i); 1473 } 1474 public TerminalNode WS(int i) { 1475 return getToken(JavadocParser.WS, i); 1476 } 1477 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1478 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1479 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1480 super(parent, invokingState); 1481 } 1482 @Override public int getRuleIndex() { return RULE_pTagClose; } 1483 @Override 1484 public void enterRule(ParseTreeListener listener) { 1485 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1486 } 1487 @Override 1488 public void exitRule(ParseTreeListener listener) { 1489 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1490 } 1491 @Override 1492 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1493 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1494 else return visitor.visitChildren(this); 1495 } 1496 } 1497 1498 public final PTagCloseContext pTagClose() throws RecognitionException { 1499 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1500 enterRule(_localctx, 14, RULE_pTagClose); 1501 int _la; 1502 try { 1503 enterOuterAlt(_localctx, 1); 1504 { 1505 setState(319); match(OPEN); 1506 setState(320); match(SLASH); 1507 setState(321); match(P_HTML_TAG_NAME); 1508 setState(325); 1509 _errHandler.sync(this); 1510 _la = _input.LA(1); 1511 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1512 { 1513 { 1514 setState(322); 1515 _la = _input.LA(1); 1516 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1517 _errHandler.recoverInline(this); 1518 } 1519 consume(); 1520 } 1521 } 1522 setState(327); 1523 _errHandler.sync(this); 1524 _la = _input.LA(1); 1525 } 1526 setState(328); match(CLOSE); 1527 } 1528 } 1529 catch (RecognitionException re) { 1530 _localctx.exception = re; 1531 _errHandler.reportError(this, re); 1532 _errHandler.recover(this, re); 1533 } 1534 finally { 1535 exitRule(); 1536 } 1537 return _localctx; 1538 } 1539 1540 public static class ParagraphContext extends ParserRuleContext { 1541 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1542 return getRuleContexts(ColgroupTagOpenContext.class); 1543 } 1544 public TbodyContext tbody(int i) { 1545 return getRuleContext(TbodyContext.class,i); 1546 } 1547 public TerminalNode CDATA(int i) { 1548 return getToken(JavadocParser.CDATA, i); 1549 } 1550 public TfootTagOpenContext tfootTagOpen(int i) { 1551 return getRuleContext(TfootTagOpenContext.class,i); 1552 } 1553 public List<DtTagOpenContext> dtTagOpen() { 1554 return getRuleContexts(DtTagOpenContext.class); 1555 } 1556 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1557 public HeadContext head(int i) { 1558 return getRuleContext(HeadContext.class,i); 1559 } 1560 public List<ColgroupContext> colgroup() { 1561 return getRuleContexts(ColgroupContext.class); 1562 } 1563 public List<TrContext> tr() { 1564 return getRuleContexts(TrContext.class); 1565 } 1566 public List<LiContext> li() { 1567 return getRuleContexts(LiContext.class); 1568 } 1569 public ThTagOpenContext thTagOpen(int i) { 1570 return getRuleContext(ThTagOpenContext.class,i); 1571 } 1572 public List<DdTagOpenContext> ddTagOpen() { 1573 return getRuleContexts(DdTagOpenContext.class); 1574 } 1575 public ColgroupContext colgroup(int i) { 1576 return getRuleContext(ColgroupContext.class,i); 1577 } 1578 public TdTagOpenContext tdTagOpen(int i) { 1579 return getRuleContext(TdTagOpenContext.class,i); 1580 } 1581 public List<ThTagOpenContext> thTagOpen() { 1582 return getRuleContexts(ThTagOpenContext.class); 1583 } 1584 public List<HeadTagOpenContext> headTagOpen() { 1585 return getRuleContexts(HeadTagOpenContext.class); 1586 } 1587 public List<HtmlTagOpenContext> htmlTagOpen() { 1588 return getRuleContexts(HtmlTagOpenContext.class); 1589 } 1590 public List<TbodyTagOpenContext> tbodyTagOpen() { 1591 return getRuleContexts(TbodyTagOpenContext.class); 1592 } 1593 public List<TheadContext> thead() { 1594 return getRuleContexts(TheadContext.class); 1595 } 1596 public LiContext li(int i) { 1597 return getRuleContext(LiContext.class,i); 1598 } 1599 public List<TfootTagOpenContext> tfootTagOpen() { 1600 return getRuleContexts(TfootTagOpenContext.class); 1601 } 1602 public List<TfootContext> tfoot() { 1603 return getRuleContexts(TfootContext.class); 1604 } 1605 public List<JavadocInlineTagContext> javadocInlineTag() { 1606 return getRuleContexts(JavadocInlineTagContext.class); 1607 } 1608 public List<HtmlCommentContext> htmlComment() { 1609 return getRuleContexts(HtmlCommentContext.class); 1610 } 1611 public OptionContext option(int i) { 1612 return getRuleContext(OptionContext.class,i); 1613 } 1614 public TrContext tr(int i) { 1615 return getRuleContext(TrContext.class,i); 1616 } 1617 public List<DtContext> dt() { 1618 return getRuleContexts(DtContext.class); 1619 } 1620 public HtmlCommentContext htmlComment(int i) { 1621 return getRuleContext(HtmlCommentContext.class,i); 1622 } 1623 public List<TdContext> td() { 1624 return getRuleContexts(TdContext.class); 1625 } 1626 public List<BodyTagOpenContext> bodyTagOpen() { 1627 return getRuleContexts(BodyTagOpenContext.class); 1628 } 1629 public DtTagOpenContext dtTagOpen(int i) { 1630 return getRuleContext(DtTagOpenContext.class,i); 1631 } 1632 public HtmlContext html(int i) { 1633 return getRuleContext(HtmlContext.class,i); 1634 } 1635 public BodyTagOpenContext bodyTagOpen(int i) { 1636 return getRuleContext(BodyTagOpenContext.class,i); 1637 } 1638 public DdTagOpenContext ddTagOpen(int i) { 1639 return getRuleContext(DdTagOpenContext.class,i); 1640 } 1641 public List<HtmlTagContext> htmlTag() { 1642 return getRuleContexts(HtmlTagContext.class); 1643 } 1644 public List<TdTagOpenContext> tdTagOpen() { 1645 return getRuleContexts(TdTagOpenContext.class); 1646 } 1647 public OptionTagOpenContext optionTagOpen(int i) { 1648 return getRuleContext(OptionTagOpenContext.class,i); 1649 } 1650 public PTagCloseContext pTagClose() { 1651 return getRuleContext(PTagCloseContext.class,0); 1652 } 1653 public LiTagOpenContext liTagOpen(int i) { 1654 return getRuleContext(LiTagOpenContext.class,i); 1655 } 1656 public TdContext td(int i) { 1657 return getRuleContext(TdContext.class,i); 1658 } 1659 public HtmlTagContext htmlTag(int i) { 1660 return getRuleContext(HtmlTagContext.class,i); 1661 } 1662 public List<SingletonTagContext> singletonTag() { 1663 return getRuleContexts(SingletonTagContext.class); 1664 } 1665 public HeadTagOpenContext headTagOpen(int i) { 1666 return getRuleContext(HeadTagOpenContext.class,i); 1667 } 1668 public TrTagOpenContext trTagOpen(int i) { 1669 return getRuleContext(TrTagOpenContext.class,i); 1670 } 1671 public List<HtmlContext> html() { 1672 return getRuleContexts(HtmlContext.class); 1673 } 1674 public JavadocInlineTagContext javadocInlineTag(int i) { 1675 return getRuleContext(JavadocInlineTagContext.class,i); 1676 } 1677 public List<ThContext> th() { 1678 return getRuleContexts(ThContext.class); 1679 } 1680 public DtContext dt(int i) { 1681 return getRuleContext(DtContext.class,i); 1682 } 1683 public TerminalNode LEADING_ASTERISK(int i) { 1684 return getToken(JavadocParser.LEADING_ASTERISK, i); 1685 } 1686 public List<TrTagOpenContext> trTagOpen() { 1687 return getRuleContexts(TrTagOpenContext.class); 1688 } 1689 public List<TbodyContext> tbody() { 1690 return getRuleContexts(TbodyContext.class); 1691 } 1692 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1693 public List<TheadTagOpenContext> theadTagOpen() { 1694 return getRuleContexts(TheadTagOpenContext.class); 1695 } 1696 public List<HeadContext> head() { 1697 return getRuleContexts(HeadContext.class); 1698 } 1699 public TerminalNode NEWLINE(int i) { 1700 return getToken(JavadocParser.NEWLINE, i); 1701 } 1702 public TextContext text(int i) { 1703 return getRuleContext(TextContext.class,i); 1704 } 1705 public List<BodyContext> body() { 1706 return getRuleContexts(BodyContext.class); 1707 } 1708 public List<OptionTagOpenContext> optionTagOpen() { 1709 return getRuleContexts(OptionTagOpenContext.class); 1710 } 1711 public List<TextContext> text() { 1712 return getRuleContexts(TextContext.class); 1713 } 1714 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1715 public TbodyTagOpenContext tbodyTagOpen(int i) { 1716 return getRuleContext(TbodyTagOpenContext.class,i); 1717 } 1718 public List<DdContext> dd() { 1719 return getRuleContexts(DdContext.class); 1720 } 1721 public TheadTagOpenContext theadTagOpen(int i) { 1722 return getRuleContext(TheadTagOpenContext.class,i); 1723 } 1724 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1725 return getRuleContext(ColgroupTagOpenContext.class,i); 1726 } 1727 public List<LiTagOpenContext> liTagOpen() { 1728 return getRuleContexts(LiTagOpenContext.class); 1729 } 1730 public DdContext dd(int i) { 1731 return getRuleContext(DdContext.class,i); 1732 } 1733 public List<OptionContext> option() { 1734 return getRuleContexts(OptionContext.class); 1735 } 1736 public TheadContext thead(int i) { 1737 return getRuleContext(TheadContext.class,i); 1738 } 1739 public BodyContext body(int i) { 1740 return getRuleContext(BodyContext.class,i); 1741 } 1742 public ThContext th(int i) { 1743 return getRuleContext(ThContext.class,i); 1744 } 1745 public PTagOpenContext pTagOpen() { 1746 return getRuleContext(PTagOpenContext.class,0); 1747 } 1748 public HtmlTagOpenContext htmlTagOpen(int i) { 1749 return getRuleContext(HtmlTagOpenContext.class,i); 1750 } 1751 public SingletonTagContext singletonTag(int i) { 1752 return getRuleContext(SingletonTagContext.class,i); 1753 } 1754 public TfootContext tfoot(int i) { 1755 return getRuleContext(TfootContext.class,i); 1756 } 1757 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1758 super(parent, invokingState); 1759 } 1760 @Override public int getRuleIndex() { return RULE_paragraph; } 1761 @Override 1762 public void enterRule(ParseTreeListener listener) { 1763 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1764 } 1765 @Override 1766 public void exitRule(ParseTreeListener listener) { 1767 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1768 } 1769 @Override 1770 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1771 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1772 else return visitor.visitChildren(this); 1773 } 1774 } 1775 1776 public final ParagraphContext paragraph() throws RecognitionException { 1777 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1778 enterRule(_localctx, 16, RULE_paragraph); 1779 try { 1780 int _alt; 1781 enterOuterAlt(_localctx, 1); 1782 { 1783 setState(330); pTagOpen(); 1784 setState(370); 1785 _errHandler.sync(this); 1786 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1787 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1788 if ( _alt==1 ) { 1789 { 1790 setState(368); 1791 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1792 case 1: 1793 { 1794 setState(331); htmlTag(); 1795 } 1796 break; 1797 1798 case 2: 1799 { 1800 setState(332); singletonTag(); 1801 } 1802 break; 1803 1804 case 3: 1805 { 1806 setState(333); li(); 1807 } 1808 break; 1809 1810 case 4: 1811 { 1812 setState(334); tr(); 1813 } 1814 break; 1815 1816 case 5: 1817 { 1818 setState(335); td(); 1819 } 1820 break; 1821 1822 case 6: 1823 { 1824 setState(336); th(); 1825 } 1826 break; 1827 1828 case 7: 1829 { 1830 setState(337); body(); 1831 } 1832 break; 1833 1834 case 8: 1835 { 1836 setState(338); colgroup(); 1837 } 1838 break; 1839 1840 case 9: 1841 { 1842 setState(339); dd(); 1843 } 1844 break; 1845 1846 case 10: 1847 { 1848 setState(340); dt(); 1849 } 1850 break; 1851 1852 case 11: 1853 { 1854 setState(341); head(); 1855 } 1856 break; 1857 1858 case 12: 1859 { 1860 setState(342); html(); 1861 } 1862 break; 1863 1864 case 13: 1865 { 1866 setState(343); option(); 1867 } 1868 break; 1869 1870 case 14: 1871 { 1872 setState(344); tbody(); 1873 } 1874 break; 1875 1876 case 15: 1877 { 1878 setState(345); thead(); 1879 } 1880 break; 1881 1882 case 16: 1883 { 1884 setState(346); tfoot(); 1885 } 1886 break; 1887 1888 case 17: 1889 { 1890 setState(347); liTagOpen(); 1891 } 1892 break; 1893 1894 case 18: 1895 { 1896 setState(348); trTagOpen(); 1897 } 1898 break; 1899 1900 case 19: 1901 { 1902 setState(349); tdTagOpen(); 1903 } 1904 break; 1905 1906 case 20: 1907 { 1908 setState(350); thTagOpen(); 1909 } 1910 break; 1911 1912 case 21: 1913 { 1914 setState(351); bodyTagOpen(); 1915 } 1916 break; 1917 1918 case 22: 1919 { 1920 setState(352); colgroupTagOpen(); 1921 } 1922 break; 1923 1924 case 23: 1925 { 1926 setState(353); ddTagOpen(); 1927 } 1928 break; 1929 1930 case 24: 1931 { 1932 setState(354); dtTagOpen(); 1933 } 1934 break; 1935 1936 case 25: 1937 { 1938 setState(355); headTagOpen(); 1939 } 1940 break; 1941 1942 case 26: 1943 { 1944 setState(356); htmlTagOpen(); 1945 } 1946 break; 1947 1948 case 27: 1949 { 1950 setState(357); optionTagOpen(); 1951 } 1952 break; 1953 1954 case 28: 1955 { 1956 setState(358); tbodyTagOpen(); 1957 } 1958 break; 1959 1960 case 29: 1961 { 1962 setState(359); theadTagOpen(); 1963 } 1964 break; 1965 1966 case 30: 1967 { 1968 setState(360); tfootTagOpen(); 1969 } 1970 break; 1971 1972 case 31: 1973 { 1974 { 1975 setState(361); 1976 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1977 setState(362); match(LEADING_ASTERISK); 1978 } 1979 } 1980 break; 1981 1982 case 32: 1983 { 1984 setState(363); htmlComment(); 1985 } 1986 break; 1987 1988 case 33: 1989 { 1990 setState(364); match(CDATA); 1991 } 1992 break; 1993 1994 case 34: 1995 { 1996 setState(365); match(NEWLINE); 1997 } 1998 break; 1999 2000 case 35: 2001 { 2002 setState(366); text(); 2003 } 2004 break; 2005 2006 case 36: 2007 { 2008 setState(367); javadocInlineTag(); 2009 } 2010 break; 2011 } 2012 } 2013 } 2014 setState(372); 2015 _errHandler.sync(this); 2016 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2017 } 2018 setState(373); pTagClose(); 2019 } 2020 } 2021 catch (RecognitionException re) { 2022 _localctx.exception = re; 2023 _errHandler.reportError(this, re); 2024 _errHandler.recover(this, re); 2025 } 2026 finally { 2027 exitRule(); 2028 } 2029 return _localctx; 2030 } 2031 2032 public static class LiTagOpenContext extends ParserRuleContext { 2033 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2034 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2035 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2036 public TerminalNode NEWLINE(int i) { 2037 return getToken(JavadocParser.NEWLINE, i); 2038 } 2039 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2040 public List<AttributeContext> attribute() { 2041 return getRuleContexts(AttributeContext.class); 2042 } 2043 public AttributeContext attribute(int i) { 2044 return getRuleContext(AttributeContext.class,i); 2045 } 2046 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2047 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2048 public TerminalNode LEADING_ASTERISK(int i) { 2049 return getToken(JavadocParser.LEADING_ASTERISK, i); 2050 } 2051 public TerminalNode WS(int i) { 2052 return getToken(JavadocParser.WS, i); 2053 } 2054 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2055 super(parent, invokingState); 2056 } 2057 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2058 @Override 2059 public void enterRule(ParseTreeListener listener) { 2060 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2061 } 2062 @Override 2063 public void exitRule(ParseTreeListener listener) { 2064 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2065 } 2066 @Override 2067 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2068 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2069 else return visitor.visitChildren(this); 2070 } 2071 } 2072 2073 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2074 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2075 enterRule(_localctx, 18, RULE_liTagOpen); 2076 int _la; 2077 try { 2078 enterOuterAlt(_localctx, 1); 2079 { 2080 setState(375); match(OPEN); 2081 setState(376); match(LI_HTML_TAG_NAME); 2082 setState(383); 2083 _errHandler.sync(this); 2084 _la = _input.LA(1); 2085 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2086 { 2087 setState(381); 2088 switch (_input.LA(1)) { 2089 case HTML_TAG_NAME: 2090 { 2091 setState(377); attribute(); 2092 } 2093 break; 2094 case NEWLINE: 2095 { 2096 setState(378); match(NEWLINE); 2097 } 2098 break; 2099 case LEADING_ASTERISK: 2100 { 2101 setState(379); match(LEADING_ASTERISK); 2102 } 2103 break; 2104 case WS: 2105 { 2106 setState(380); match(WS); 2107 } 2108 break; 2109 default: 2110 throw new NoViableAltException(this); 2111 } 2112 } 2113 setState(385); 2114 _errHandler.sync(this); 2115 _la = _input.LA(1); 2116 } 2117 setState(386); match(CLOSE); 2118 } 2119 } 2120 catch (RecognitionException re) { 2121 _localctx.exception = re; 2122 _errHandler.reportError(this, re); 2123 _errHandler.recover(this, re); 2124 } 2125 finally { 2126 exitRule(); 2127 } 2128 return _localctx; 2129 } 2130 2131 public static class LiTagCloseContext extends ParserRuleContext { 2132 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2133 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2134 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2135 public TerminalNode NEWLINE(int i) { 2136 return getToken(JavadocParser.NEWLINE, i); 2137 } 2138 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2139 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2140 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2141 public TerminalNode LEADING_ASTERISK(int i) { 2142 return getToken(JavadocParser.LEADING_ASTERISK, i); 2143 } 2144 public TerminalNode WS(int i) { 2145 return getToken(JavadocParser.WS, i); 2146 } 2147 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2148 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2149 super(parent, invokingState); 2150 } 2151 @Override public int getRuleIndex() { return RULE_liTagClose; } 2152 @Override 2153 public void enterRule(ParseTreeListener listener) { 2154 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2155 } 2156 @Override 2157 public void exitRule(ParseTreeListener listener) { 2158 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2159 } 2160 @Override 2161 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2162 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2163 else return visitor.visitChildren(this); 2164 } 2165 } 2166 2167 public final LiTagCloseContext liTagClose() throws RecognitionException { 2168 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2169 enterRule(_localctx, 20, RULE_liTagClose); 2170 int _la; 2171 try { 2172 enterOuterAlt(_localctx, 1); 2173 { 2174 setState(388); match(OPEN); 2175 setState(389); match(SLASH); 2176 setState(390); match(LI_HTML_TAG_NAME); 2177 setState(394); 2178 _errHandler.sync(this); 2179 _la = _input.LA(1); 2180 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2181 { 2182 { 2183 setState(391); 2184 _la = _input.LA(1); 2185 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2186 _errHandler.recoverInline(this); 2187 } 2188 consume(); 2189 } 2190 } 2191 setState(396); 2192 _errHandler.sync(this); 2193 _la = _input.LA(1); 2194 } 2195 setState(397); match(CLOSE); 2196 } 2197 } 2198 catch (RecognitionException re) { 2199 _localctx.exception = re; 2200 _errHandler.reportError(this, re); 2201 _errHandler.recover(this, re); 2202 } 2203 finally { 2204 exitRule(); 2205 } 2206 return _localctx; 2207 } 2208 2209 public static class LiContext extends ParserRuleContext { 2210 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2211 return getRuleContexts(ColgroupTagOpenContext.class); 2212 } 2213 public TbodyContext tbody(int i) { 2214 return getRuleContext(TbodyContext.class,i); 2215 } 2216 public TerminalNode CDATA(int i) { 2217 return getToken(JavadocParser.CDATA, i); 2218 } 2219 public TfootTagOpenContext tfootTagOpen(int i) { 2220 return getRuleContext(TfootTagOpenContext.class,i); 2221 } 2222 public List<DtTagOpenContext> dtTagOpen() { 2223 return getRuleContexts(DtTagOpenContext.class); 2224 } 2225 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2226 public HeadContext head(int i) { 2227 return getRuleContext(HeadContext.class,i); 2228 } 2229 public List<ColgroupContext> colgroup() { 2230 return getRuleContexts(ColgroupContext.class); 2231 } 2232 public List<TrContext> tr() { 2233 return getRuleContexts(TrContext.class); 2234 } 2235 public ThTagOpenContext thTagOpen(int i) { 2236 return getRuleContext(ThTagOpenContext.class,i); 2237 } 2238 public List<DdTagOpenContext> ddTagOpen() { 2239 return getRuleContexts(DdTagOpenContext.class); 2240 } 2241 public ColgroupContext colgroup(int i) { 2242 return getRuleContext(ColgroupContext.class,i); 2243 } 2244 public TdTagOpenContext tdTagOpen(int i) { 2245 return getRuleContext(TdTagOpenContext.class,i); 2246 } 2247 public List<ThTagOpenContext> thTagOpen() { 2248 return getRuleContexts(ThTagOpenContext.class); 2249 } 2250 public List<HeadTagOpenContext> headTagOpen() { 2251 return getRuleContexts(HeadTagOpenContext.class); 2252 } 2253 public List<HtmlTagOpenContext> htmlTagOpen() { 2254 return getRuleContexts(HtmlTagOpenContext.class); 2255 } 2256 public List<TbodyTagOpenContext> tbodyTagOpen() { 2257 return getRuleContexts(TbodyTagOpenContext.class); 2258 } 2259 public List<TheadContext> thead() { 2260 return getRuleContexts(TheadContext.class); 2261 } 2262 public List<TfootTagOpenContext> tfootTagOpen() { 2263 return getRuleContexts(TfootTagOpenContext.class); 2264 } 2265 public List<TfootContext> tfoot() { 2266 return getRuleContexts(TfootContext.class); 2267 } 2268 public List<JavadocInlineTagContext> javadocInlineTag() { 2269 return getRuleContexts(JavadocInlineTagContext.class); 2270 } 2271 public LiTagCloseContext liTagClose() { 2272 return getRuleContext(LiTagCloseContext.class,0); 2273 } 2274 public List<HtmlCommentContext> htmlComment() { 2275 return getRuleContexts(HtmlCommentContext.class); 2276 } 2277 public OptionContext option(int i) { 2278 return getRuleContext(OptionContext.class,i); 2279 } 2280 public TrContext tr(int i) { 2281 return getRuleContext(TrContext.class,i); 2282 } 2283 public List<DtContext> dt() { 2284 return getRuleContexts(DtContext.class); 2285 } 2286 public HtmlCommentContext htmlComment(int i) { 2287 return getRuleContext(HtmlCommentContext.class,i); 2288 } 2289 public List<TdContext> td() { 2290 return getRuleContexts(TdContext.class); 2291 } 2292 public List<BodyTagOpenContext> bodyTagOpen() { 2293 return getRuleContexts(BodyTagOpenContext.class); 2294 } 2295 public DtTagOpenContext dtTagOpen(int i) { 2296 return getRuleContext(DtTagOpenContext.class,i); 2297 } 2298 public HtmlContext html(int i) { 2299 return getRuleContext(HtmlContext.class,i); 2300 } 2301 public BodyTagOpenContext bodyTagOpen(int i) { 2302 return getRuleContext(BodyTagOpenContext.class,i); 2303 } 2304 public DdTagOpenContext ddTagOpen(int i) { 2305 return getRuleContext(DdTagOpenContext.class,i); 2306 } 2307 public List<HtmlTagContext> htmlTag() { 2308 return getRuleContexts(HtmlTagContext.class); 2309 } 2310 public ParagraphContext paragraph(int i) { 2311 return getRuleContext(ParagraphContext.class,i); 2312 } 2313 public List<TdTagOpenContext> tdTagOpen() { 2314 return getRuleContexts(TdTagOpenContext.class); 2315 } 2316 public OptionTagOpenContext optionTagOpen(int i) { 2317 return getRuleContext(OptionTagOpenContext.class,i); 2318 } 2319 public List<ParagraphContext> paragraph() { 2320 return getRuleContexts(ParagraphContext.class); 2321 } 2322 public TdContext td(int i) { 2323 return getRuleContext(TdContext.class,i); 2324 } 2325 public HtmlTagContext htmlTag(int i) { 2326 return getRuleContext(HtmlTagContext.class,i); 2327 } 2328 public List<SingletonTagContext> singletonTag() { 2329 return getRuleContexts(SingletonTagContext.class); 2330 } 2331 public HeadTagOpenContext headTagOpen(int i) { 2332 return getRuleContext(HeadTagOpenContext.class,i); 2333 } 2334 public TrTagOpenContext trTagOpen(int i) { 2335 return getRuleContext(TrTagOpenContext.class,i); 2336 } 2337 public List<HtmlContext> html() { 2338 return getRuleContexts(HtmlContext.class); 2339 } 2340 public JavadocInlineTagContext javadocInlineTag(int i) { 2341 return getRuleContext(JavadocInlineTagContext.class,i); 2342 } 2343 public List<ThContext> th() { 2344 return getRuleContexts(ThContext.class); 2345 } 2346 public DtContext dt(int i) { 2347 return getRuleContext(DtContext.class,i); 2348 } 2349 public PTagOpenContext pTagOpen(int i) { 2350 return getRuleContext(PTagOpenContext.class,i); 2351 } 2352 public TerminalNode LEADING_ASTERISK(int i) { 2353 return getToken(JavadocParser.LEADING_ASTERISK, i); 2354 } 2355 public List<TrTagOpenContext> trTagOpen() { 2356 return getRuleContexts(TrTagOpenContext.class); 2357 } 2358 public List<TbodyContext> tbody() { 2359 return getRuleContexts(TbodyContext.class); 2360 } 2361 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2362 public List<TheadTagOpenContext> theadTagOpen() { 2363 return getRuleContexts(TheadTagOpenContext.class); 2364 } 2365 public List<HeadContext> head() { 2366 return getRuleContexts(HeadContext.class); 2367 } 2368 public TerminalNode NEWLINE(int i) { 2369 return getToken(JavadocParser.NEWLINE, i); 2370 } 2371 public TextContext text(int i) { 2372 return getRuleContext(TextContext.class,i); 2373 } 2374 public List<BodyContext> body() { 2375 return getRuleContexts(BodyContext.class); 2376 } 2377 public List<OptionTagOpenContext> optionTagOpen() { 2378 return getRuleContexts(OptionTagOpenContext.class); 2379 } 2380 public List<TextContext> text() { 2381 return getRuleContexts(TextContext.class); 2382 } 2383 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2384 public TbodyTagOpenContext tbodyTagOpen(int i) { 2385 return getRuleContext(TbodyTagOpenContext.class,i); 2386 } 2387 public List<DdContext> dd() { 2388 return getRuleContexts(DdContext.class); 2389 } 2390 public TheadTagOpenContext theadTagOpen(int i) { 2391 return getRuleContext(TheadTagOpenContext.class,i); 2392 } 2393 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2394 return getRuleContext(ColgroupTagOpenContext.class,i); 2395 } 2396 public LiTagOpenContext liTagOpen() { 2397 return getRuleContext(LiTagOpenContext.class,0); 2398 } 2399 public DdContext dd(int i) { 2400 return getRuleContext(DdContext.class,i); 2401 } 2402 public List<OptionContext> option() { 2403 return getRuleContexts(OptionContext.class); 2404 } 2405 public TheadContext thead(int i) { 2406 return getRuleContext(TheadContext.class,i); 2407 } 2408 public BodyContext body(int i) { 2409 return getRuleContext(BodyContext.class,i); 2410 } 2411 public ThContext th(int i) { 2412 return getRuleContext(ThContext.class,i); 2413 } 2414 public List<PTagOpenContext> pTagOpen() { 2415 return getRuleContexts(PTagOpenContext.class); 2416 } 2417 public HtmlTagOpenContext htmlTagOpen(int i) { 2418 return getRuleContext(HtmlTagOpenContext.class,i); 2419 } 2420 public SingletonTagContext singletonTag(int i) { 2421 return getRuleContext(SingletonTagContext.class,i); 2422 } 2423 public TfootContext tfoot(int i) { 2424 return getRuleContext(TfootContext.class,i); 2425 } 2426 public LiContext(ParserRuleContext parent, int invokingState) { 2427 super(parent, invokingState); 2428 } 2429 @Override public int getRuleIndex() { return RULE_li; } 2430 @Override 2431 public void enterRule(ParseTreeListener listener) { 2432 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2433 } 2434 @Override 2435 public void exitRule(ParseTreeListener listener) { 2436 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2437 } 2438 @Override 2439 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2440 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2441 else return visitor.visitChildren(this); 2442 } 2443 } 2444 2445 public final LiContext li() throws RecognitionException { 2446 LiContext _localctx = new LiContext(_ctx, getState()); 2447 enterRule(_localctx, 22, RULE_li); 2448 try { 2449 int _alt; 2450 enterOuterAlt(_localctx, 1); 2451 { 2452 setState(399); liTagOpen(); 2453 setState(439); 2454 _errHandler.sync(this); 2455 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2456 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2457 if ( _alt==1 ) { 2458 { 2459 setState(437); 2460 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2461 case 1: 2462 { 2463 setState(400); htmlTag(); 2464 } 2465 break; 2466 2467 case 2: 2468 { 2469 setState(401); singletonTag(); 2470 } 2471 break; 2472 2473 case 3: 2474 { 2475 setState(402); paragraph(); 2476 } 2477 break; 2478 2479 case 4: 2480 { 2481 setState(403); tr(); 2482 } 2483 break; 2484 2485 case 5: 2486 { 2487 setState(404); td(); 2488 } 2489 break; 2490 2491 case 6: 2492 { 2493 setState(405); th(); 2494 } 2495 break; 2496 2497 case 7: 2498 { 2499 setState(406); body(); 2500 } 2501 break; 2502 2503 case 8: 2504 { 2505 setState(407); colgroup(); 2506 } 2507 break; 2508 2509 case 9: 2510 { 2511 setState(408); dd(); 2512 } 2513 break; 2514 2515 case 10: 2516 { 2517 setState(409); dt(); 2518 } 2519 break; 2520 2521 case 11: 2522 { 2523 setState(410); head(); 2524 } 2525 break; 2526 2527 case 12: 2528 { 2529 setState(411); html(); 2530 } 2531 break; 2532 2533 case 13: 2534 { 2535 setState(412); option(); 2536 } 2537 break; 2538 2539 case 14: 2540 { 2541 setState(413); tbody(); 2542 } 2543 break; 2544 2545 case 15: 2546 { 2547 setState(414); thead(); 2548 } 2549 break; 2550 2551 case 16: 2552 { 2553 setState(415); tfoot(); 2554 } 2555 break; 2556 2557 case 17: 2558 { 2559 setState(416); pTagOpen(); 2560 } 2561 break; 2562 2563 case 18: 2564 { 2565 setState(417); trTagOpen(); 2566 } 2567 break; 2568 2569 case 19: 2570 { 2571 setState(418); tdTagOpen(); 2572 } 2573 break; 2574 2575 case 20: 2576 { 2577 setState(419); thTagOpen(); 2578 } 2579 break; 2580 2581 case 21: 2582 { 2583 setState(420); bodyTagOpen(); 2584 } 2585 break; 2586 2587 case 22: 2588 { 2589 setState(421); colgroupTagOpen(); 2590 } 2591 break; 2592 2593 case 23: 2594 { 2595 setState(422); ddTagOpen(); 2596 } 2597 break; 2598 2599 case 24: 2600 { 2601 setState(423); dtTagOpen(); 2602 } 2603 break; 2604 2605 case 25: 2606 { 2607 setState(424); headTagOpen(); 2608 } 2609 break; 2610 2611 case 26: 2612 { 2613 setState(425); htmlTagOpen(); 2614 } 2615 break; 2616 2617 case 27: 2618 { 2619 setState(426); optionTagOpen(); 2620 } 2621 break; 2622 2623 case 28: 2624 { 2625 setState(427); tbodyTagOpen(); 2626 } 2627 break; 2628 2629 case 29: 2630 { 2631 setState(428); theadTagOpen(); 2632 } 2633 break; 2634 2635 case 30: 2636 { 2637 setState(429); tfootTagOpen(); 2638 } 2639 break; 2640 2641 case 31: 2642 { 2643 { 2644 setState(430); 2645 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2646 setState(431); match(LEADING_ASTERISK); 2647 } 2648 } 2649 break; 2650 2651 case 32: 2652 { 2653 setState(432); htmlComment(); 2654 } 2655 break; 2656 2657 case 33: 2658 { 2659 setState(433); match(CDATA); 2660 } 2661 break; 2662 2663 case 34: 2664 { 2665 setState(434); match(NEWLINE); 2666 } 2667 break; 2668 2669 case 35: 2670 { 2671 setState(435); text(); 2672 } 2673 break; 2674 2675 case 36: 2676 { 2677 setState(436); javadocInlineTag(); 2678 } 2679 break; 2680 } 2681 } 2682 } 2683 setState(441); 2684 _errHandler.sync(this); 2685 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2686 } 2687 setState(442); liTagClose(); 2688 } 2689 } 2690 catch (RecognitionException re) { 2691 _localctx.exception = re; 2692 _errHandler.reportError(this, re); 2693 _errHandler.recover(this, re); 2694 } 2695 finally { 2696 exitRule(); 2697 } 2698 return _localctx; 2699 } 2700 2701 public static class TrTagOpenContext extends ParserRuleContext { 2702 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2703 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2704 public TerminalNode NEWLINE(int i) { 2705 return getToken(JavadocParser.NEWLINE, i); 2706 } 2707 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2708 public List<AttributeContext> attribute() { 2709 return getRuleContexts(AttributeContext.class); 2710 } 2711 public AttributeContext attribute(int i) { 2712 return getRuleContext(AttributeContext.class,i); 2713 } 2714 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2715 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2716 public TerminalNode LEADING_ASTERISK(int i) { 2717 return getToken(JavadocParser.LEADING_ASTERISK, i); 2718 } 2719 public TerminalNode WS(int i) { 2720 return getToken(JavadocParser.WS, i); 2721 } 2722 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2723 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2724 super(parent, invokingState); 2725 } 2726 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2727 @Override 2728 public void enterRule(ParseTreeListener listener) { 2729 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2730 } 2731 @Override 2732 public void exitRule(ParseTreeListener listener) { 2733 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2734 } 2735 @Override 2736 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2737 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2738 else return visitor.visitChildren(this); 2739 } 2740 } 2741 2742 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2743 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2744 enterRule(_localctx, 24, RULE_trTagOpen); 2745 int _la; 2746 try { 2747 enterOuterAlt(_localctx, 1); 2748 { 2749 setState(444); match(OPEN); 2750 setState(445); match(TR_HTML_TAG_NAME); 2751 setState(452); 2752 _errHandler.sync(this); 2753 _la = _input.LA(1); 2754 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2755 { 2756 setState(450); 2757 switch (_input.LA(1)) { 2758 case HTML_TAG_NAME: 2759 { 2760 setState(446); attribute(); 2761 } 2762 break; 2763 case NEWLINE: 2764 { 2765 setState(447); match(NEWLINE); 2766 } 2767 break; 2768 case LEADING_ASTERISK: 2769 { 2770 setState(448); match(LEADING_ASTERISK); 2771 } 2772 break; 2773 case WS: 2774 { 2775 setState(449); match(WS); 2776 } 2777 break; 2778 default: 2779 throw new NoViableAltException(this); 2780 } 2781 } 2782 setState(454); 2783 _errHandler.sync(this); 2784 _la = _input.LA(1); 2785 } 2786 setState(455); match(CLOSE); 2787 } 2788 } 2789 catch (RecognitionException re) { 2790 _localctx.exception = re; 2791 _errHandler.reportError(this, re); 2792 _errHandler.recover(this, re); 2793 } 2794 finally { 2795 exitRule(); 2796 } 2797 return _localctx; 2798 } 2799 2800 public static class TrTagCloseContext extends ParserRuleContext { 2801 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2802 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2803 public TerminalNode NEWLINE(int i) { 2804 return getToken(JavadocParser.NEWLINE, i); 2805 } 2806 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2807 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2808 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2809 public TerminalNode LEADING_ASTERISK(int i) { 2810 return getToken(JavadocParser.LEADING_ASTERISK, i); 2811 } 2812 public TerminalNode WS(int i) { 2813 return getToken(JavadocParser.WS, i); 2814 } 2815 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2816 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2817 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2818 super(parent, invokingState); 2819 } 2820 @Override public int getRuleIndex() { return RULE_trTagClose; } 2821 @Override 2822 public void enterRule(ParseTreeListener listener) { 2823 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2824 } 2825 @Override 2826 public void exitRule(ParseTreeListener listener) { 2827 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2828 } 2829 @Override 2830 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2831 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2832 else return visitor.visitChildren(this); 2833 } 2834 } 2835 2836 public final TrTagCloseContext trTagClose() throws RecognitionException { 2837 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2838 enterRule(_localctx, 26, RULE_trTagClose); 2839 int _la; 2840 try { 2841 enterOuterAlt(_localctx, 1); 2842 { 2843 setState(457); match(OPEN); 2844 setState(458); match(SLASH); 2845 setState(459); match(TR_HTML_TAG_NAME); 2846 setState(463); 2847 _errHandler.sync(this); 2848 _la = _input.LA(1); 2849 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2850 { 2851 { 2852 setState(460); 2853 _la = _input.LA(1); 2854 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2855 _errHandler.recoverInline(this); 2856 } 2857 consume(); 2858 } 2859 } 2860 setState(465); 2861 _errHandler.sync(this); 2862 _la = _input.LA(1); 2863 } 2864 setState(466); match(CLOSE); 2865 } 2866 } 2867 catch (RecognitionException re) { 2868 _localctx.exception = re; 2869 _errHandler.reportError(this, re); 2870 _errHandler.recover(this, re); 2871 } 2872 finally { 2873 exitRule(); 2874 } 2875 return _localctx; 2876 } 2877 2878 public static class TrContext extends ParserRuleContext { 2879 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2880 return getRuleContexts(ColgroupTagOpenContext.class); 2881 } 2882 public TbodyContext tbody(int i) { 2883 return getRuleContext(TbodyContext.class,i); 2884 } 2885 public TerminalNode CDATA(int i) { 2886 return getToken(JavadocParser.CDATA, i); 2887 } 2888 public TfootTagOpenContext tfootTagOpen(int i) { 2889 return getRuleContext(TfootTagOpenContext.class,i); 2890 } 2891 public List<DtTagOpenContext> dtTagOpen() { 2892 return getRuleContexts(DtTagOpenContext.class); 2893 } 2894 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2895 public HeadContext head(int i) { 2896 return getRuleContext(HeadContext.class,i); 2897 } 2898 public List<ColgroupContext> colgroup() { 2899 return getRuleContexts(ColgroupContext.class); 2900 } 2901 public List<LiContext> li() { 2902 return getRuleContexts(LiContext.class); 2903 } 2904 public ThTagOpenContext thTagOpen(int i) { 2905 return getRuleContext(ThTagOpenContext.class,i); 2906 } 2907 public List<DdTagOpenContext> ddTagOpen() { 2908 return getRuleContexts(DdTagOpenContext.class); 2909 } 2910 public ColgroupContext colgroup(int i) { 2911 return getRuleContext(ColgroupContext.class,i); 2912 } 2913 public TdTagOpenContext tdTagOpen(int i) { 2914 return getRuleContext(TdTagOpenContext.class,i); 2915 } 2916 public List<ThTagOpenContext> thTagOpen() { 2917 return getRuleContexts(ThTagOpenContext.class); 2918 } 2919 public List<HeadTagOpenContext> headTagOpen() { 2920 return getRuleContexts(HeadTagOpenContext.class); 2921 } 2922 public List<HtmlTagOpenContext> htmlTagOpen() { 2923 return getRuleContexts(HtmlTagOpenContext.class); 2924 } 2925 public List<TbodyTagOpenContext> tbodyTagOpen() { 2926 return getRuleContexts(TbodyTagOpenContext.class); 2927 } 2928 public List<TheadContext> thead() { 2929 return getRuleContexts(TheadContext.class); 2930 } 2931 public LiContext li(int i) { 2932 return getRuleContext(LiContext.class,i); 2933 } 2934 public List<TfootTagOpenContext> tfootTagOpen() { 2935 return getRuleContexts(TfootTagOpenContext.class); 2936 } 2937 public List<TfootContext> tfoot() { 2938 return getRuleContexts(TfootContext.class); 2939 } 2940 public List<JavadocInlineTagContext> javadocInlineTag() { 2941 return getRuleContexts(JavadocInlineTagContext.class); 2942 } 2943 public List<HtmlCommentContext> htmlComment() { 2944 return getRuleContexts(HtmlCommentContext.class); 2945 } 2946 public OptionContext option(int i) { 2947 return getRuleContext(OptionContext.class,i); 2948 } 2949 public List<DtContext> dt() { 2950 return getRuleContexts(DtContext.class); 2951 } 2952 public HtmlCommentContext htmlComment(int i) { 2953 return getRuleContext(HtmlCommentContext.class,i); 2954 } 2955 public List<TdContext> td() { 2956 return getRuleContexts(TdContext.class); 2957 } 2958 public List<BodyTagOpenContext> bodyTagOpen() { 2959 return getRuleContexts(BodyTagOpenContext.class); 2960 } 2961 public DtTagOpenContext dtTagOpen(int i) { 2962 return getRuleContext(DtTagOpenContext.class,i); 2963 } 2964 public HtmlContext html(int i) { 2965 return getRuleContext(HtmlContext.class,i); 2966 } 2967 public BodyTagOpenContext bodyTagOpen(int i) { 2968 return getRuleContext(BodyTagOpenContext.class,i); 2969 } 2970 public DdTagOpenContext ddTagOpen(int i) { 2971 return getRuleContext(DdTagOpenContext.class,i); 2972 } 2973 public TrTagCloseContext trTagClose() { 2974 return getRuleContext(TrTagCloseContext.class,0); 2975 } 2976 public List<HtmlTagContext> htmlTag() { 2977 return getRuleContexts(HtmlTagContext.class); 2978 } 2979 public ParagraphContext paragraph(int i) { 2980 return getRuleContext(ParagraphContext.class,i); 2981 } 2982 public List<TdTagOpenContext> tdTagOpen() { 2983 return getRuleContexts(TdTagOpenContext.class); 2984 } 2985 public OptionTagOpenContext optionTagOpen(int i) { 2986 return getRuleContext(OptionTagOpenContext.class,i); 2987 } 2988 public LiTagOpenContext liTagOpen(int i) { 2989 return getRuleContext(LiTagOpenContext.class,i); 2990 } 2991 public List<ParagraphContext> paragraph() { 2992 return getRuleContexts(ParagraphContext.class); 2993 } 2994 public TdContext td(int i) { 2995 return getRuleContext(TdContext.class,i); 2996 } 2997 public HtmlTagContext htmlTag(int i) { 2998 return getRuleContext(HtmlTagContext.class,i); 2999 } 3000 public List<SingletonTagContext> singletonTag() { 3001 return getRuleContexts(SingletonTagContext.class); 3002 } 3003 public HeadTagOpenContext headTagOpen(int i) { 3004 return getRuleContext(HeadTagOpenContext.class,i); 3005 } 3006 public List<HtmlContext> html() { 3007 return getRuleContexts(HtmlContext.class); 3008 } 3009 public JavadocInlineTagContext javadocInlineTag(int i) { 3010 return getRuleContext(JavadocInlineTagContext.class,i); 3011 } 3012 public List<ThContext> th() { 3013 return getRuleContexts(ThContext.class); 3014 } 3015 public DtContext dt(int i) { 3016 return getRuleContext(DtContext.class,i); 3017 } 3018 public PTagOpenContext pTagOpen(int i) { 3019 return getRuleContext(PTagOpenContext.class,i); 3020 } 3021 public TerminalNode LEADING_ASTERISK(int i) { 3022 return getToken(JavadocParser.LEADING_ASTERISK, i); 3023 } 3024 public TrTagOpenContext trTagOpen() { 3025 return getRuleContext(TrTagOpenContext.class,0); 3026 } 3027 public List<TbodyContext> tbody() { 3028 return getRuleContexts(TbodyContext.class); 3029 } 3030 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3031 public List<TheadTagOpenContext> theadTagOpen() { 3032 return getRuleContexts(TheadTagOpenContext.class); 3033 } 3034 public List<HeadContext> head() { 3035 return getRuleContexts(HeadContext.class); 3036 } 3037 public TerminalNode NEWLINE(int i) { 3038 return getToken(JavadocParser.NEWLINE, i); 3039 } 3040 public TextContext text(int i) { 3041 return getRuleContext(TextContext.class,i); 3042 } 3043 public List<BodyContext> body() { 3044 return getRuleContexts(BodyContext.class); 3045 } 3046 public List<OptionTagOpenContext> optionTagOpen() { 3047 return getRuleContexts(OptionTagOpenContext.class); 3048 } 3049 public List<TextContext> text() { 3050 return getRuleContexts(TextContext.class); 3051 } 3052 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3053 public TbodyTagOpenContext tbodyTagOpen(int i) { 3054 return getRuleContext(TbodyTagOpenContext.class,i); 3055 } 3056 public List<DdContext> dd() { 3057 return getRuleContexts(DdContext.class); 3058 } 3059 public TheadTagOpenContext theadTagOpen(int i) { 3060 return getRuleContext(TheadTagOpenContext.class,i); 3061 } 3062 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3063 return getRuleContext(ColgroupTagOpenContext.class,i); 3064 } 3065 public List<LiTagOpenContext> liTagOpen() { 3066 return getRuleContexts(LiTagOpenContext.class); 3067 } 3068 public DdContext dd(int i) { 3069 return getRuleContext(DdContext.class,i); 3070 } 3071 public List<OptionContext> option() { 3072 return getRuleContexts(OptionContext.class); 3073 } 3074 public TheadContext thead(int i) { 3075 return getRuleContext(TheadContext.class,i); 3076 } 3077 public BodyContext body(int i) { 3078 return getRuleContext(BodyContext.class,i); 3079 } 3080 public ThContext th(int i) { 3081 return getRuleContext(ThContext.class,i); 3082 } 3083 public List<PTagOpenContext> pTagOpen() { 3084 return getRuleContexts(PTagOpenContext.class); 3085 } 3086 public HtmlTagOpenContext htmlTagOpen(int i) { 3087 return getRuleContext(HtmlTagOpenContext.class,i); 3088 } 3089 public SingletonTagContext singletonTag(int i) { 3090 return getRuleContext(SingletonTagContext.class,i); 3091 } 3092 public TfootContext tfoot(int i) { 3093 return getRuleContext(TfootContext.class,i); 3094 } 3095 public TrContext(ParserRuleContext parent, int invokingState) { 3096 super(parent, invokingState); 3097 } 3098 @Override public int getRuleIndex() { return RULE_tr; } 3099 @Override 3100 public void enterRule(ParseTreeListener listener) { 3101 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3102 } 3103 @Override 3104 public void exitRule(ParseTreeListener listener) { 3105 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3106 } 3107 @Override 3108 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3109 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3110 else return visitor.visitChildren(this); 3111 } 3112 } 3113 3114 public final TrContext tr() throws RecognitionException { 3115 TrContext _localctx = new TrContext(_ctx, getState()); 3116 enterRule(_localctx, 28, RULE_tr); 3117 try { 3118 int _alt; 3119 enterOuterAlt(_localctx, 1); 3120 { 3121 setState(468); trTagOpen(); 3122 setState(508); 3123 _errHandler.sync(this); 3124 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3125 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3126 if ( _alt==1 ) { 3127 { 3128 setState(506); 3129 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3130 case 1: 3131 { 3132 setState(469); htmlTag(); 3133 } 3134 break; 3135 3136 case 2: 3137 { 3138 setState(470); singletonTag(); 3139 } 3140 break; 3141 3142 case 3: 3143 { 3144 setState(471); paragraph(); 3145 } 3146 break; 3147 3148 case 4: 3149 { 3150 setState(472); li(); 3151 } 3152 break; 3153 3154 case 5: 3155 { 3156 setState(473); td(); 3157 } 3158 break; 3159 3160 case 6: 3161 { 3162 setState(474); th(); 3163 } 3164 break; 3165 3166 case 7: 3167 { 3168 setState(475); body(); 3169 } 3170 break; 3171 3172 case 8: 3173 { 3174 setState(476); colgroup(); 3175 } 3176 break; 3177 3178 case 9: 3179 { 3180 setState(477); dd(); 3181 } 3182 break; 3183 3184 case 10: 3185 { 3186 setState(478); dt(); 3187 } 3188 break; 3189 3190 case 11: 3191 { 3192 setState(479); head(); 3193 } 3194 break; 3195 3196 case 12: 3197 { 3198 setState(480); html(); 3199 } 3200 break; 3201 3202 case 13: 3203 { 3204 setState(481); option(); 3205 } 3206 break; 3207 3208 case 14: 3209 { 3210 setState(482); tbody(); 3211 } 3212 break; 3213 3214 case 15: 3215 { 3216 setState(483); thead(); 3217 } 3218 break; 3219 3220 case 16: 3221 { 3222 setState(484); tfoot(); 3223 } 3224 break; 3225 3226 case 17: 3227 { 3228 setState(485); pTagOpen(); 3229 } 3230 break; 3231 3232 case 18: 3233 { 3234 setState(486); liTagOpen(); 3235 } 3236 break; 3237 3238 case 19: 3239 { 3240 setState(487); tdTagOpen(); 3241 } 3242 break; 3243 3244 case 20: 3245 { 3246 setState(488); thTagOpen(); 3247 } 3248 break; 3249 3250 case 21: 3251 { 3252 setState(489); bodyTagOpen(); 3253 } 3254 break; 3255 3256 case 22: 3257 { 3258 setState(490); colgroupTagOpen(); 3259 } 3260 break; 3261 3262 case 23: 3263 { 3264 setState(491); ddTagOpen(); 3265 } 3266 break; 3267 3268 case 24: 3269 { 3270 setState(492); dtTagOpen(); 3271 } 3272 break; 3273 3274 case 25: 3275 { 3276 setState(493); headTagOpen(); 3277 } 3278 break; 3279 3280 case 26: 3281 { 3282 setState(494); htmlTagOpen(); 3283 } 3284 break; 3285 3286 case 27: 3287 { 3288 setState(495); optionTagOpen(); 3289 } 3290 break; 3291 3292 case 28: 3293 { 3294 setState(496); tbodyTagOpen(); 3295 } 3296 break; 3297 3298 case 29: 3299 { 3300 setState(497); theadTagOpen(); 3301 } 3302 break; 3303 3304 case 30: 3305 { 3306 setState(498); tfootTagOpen(); 3307 } 3308 break; 3309 3310 case 31: 3311 { 3312 { 3313 setState(499); 3314 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3315 setState(500); match(LEADING_ASTERISK); 3316 } 3317 } 3318 break; 3319 3320 case 32: 3321 { 3322 setState(501); htmlComment(); 3323 } 3324 break; 3325 3326 case 33: 3327 { 3328 setState(502); match(CDATA); 3329 } 3330 break; 3331 3332 case 34: 3333 { 3334 setState(503); match(NEWLINE); 3335 } 3336 break; 3337 3338 case 35: 3339 { 3340 setState(504); text(); 3341 } 3342 break; 3343 3344 case 36: 3345 { 3346 setState(505); javadocInlineTag(); 3347 } 3348 break; 3349 } 3350 } 3351 } 3352 setState(510); 3353 _errHandler.sync(this); 3354 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3355 } 3356 setState(511); trTagClose(); 3357 } 3358 } 3359 catch (RecognitionException re) { 3360 _localctx.exception = re; 3361 _errHandler.reportError(this, re); 3362 _errHandler.recover(this, re); 3363 } 3364 finally { 3365 exitRule(); 3366 } 3367 return _localctx; 3368 } 3369 3370 public static class TdTagOpenContext extends ParserRuleContext { 3371 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3372 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3373 public TerminalNode NEWLINE(int i) { 3374 return getToken(JavadocParser.NEWLINE, i); 3375 } 3376 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3377 public List<AttributeContext> attribute() { 3378 return getRuleContexts(AttributeContext.class); 3379 } 3380 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3381 public AttributeContext attribute(int i) { 3382 return getRuleContext(AttributeContext.class,i); 3383 } 3384 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3385 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3386 public TerminalNode LEADING_ASTERISK(int i) { 3387 return getToken(JavadocParser.LEADING_ASTERISK, i); 3388 } 3389 public TerminalNode WS(int i) { 3390 return getToken(JavadocParser.WS, i); 3391 } 3392 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3393 super(parent, invokingState); 3394 } 3395 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3396 @Override 3397 public void enterRule(ParseTreeListener listener) { 3398 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3399 } 3400 @Override 3401 public void exitRule(ParseTreeListener listener) { 3402 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3403 } 3404 @Override 3405 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3406 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3407 else return visitor.visitChildren(this); 3408 } 3409 } 3410 3411 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3412 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3413 enterRule(_localctx, 30, RULE_tdTagOpen); 3414 int _la; 3415 try { 3416 enterOuterAlt(_localctx, 1); 3417 { 3418 setState(513); match(OPEN); 3419 setState(514); match(TD_HTML_TAG_NAME); 3420 setState(521); 3421 _errHandler.sync(this); 3422 _la = _input.LA(1); 3423 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3424 { 3425 setState(519); 3426 switch (_input.LA(1)) { 3427 case HTML_TAG_NAME: 3428 { 3429 setState(515); attribute(); 3430 } 3431 break; 3432 case NEWLINE: 3433 { 3434 setState(516); match(NEWLINE); 3435 } 3436 break; 3437 case LEADING_ASTERISK: 3438 { 3439 setState(517); match(LEADING_ASTERISK); 3440 } 3441 break; 3442 case WS: 3443 { 3444 setState(518); match(WS); 3445 } 3446 break; 3447 default: 3448 throw new NoViableAltException(this); 3449 } 3450 } 3451 setState(523); 3452 _errHandler.sync(this); 3453 _la = _input.LA(1); 3454 } 3455 setState(524); match(CLOSE); 3456 } 3457 } 3458 catch (RecognitionException re) { 3459 _localctx.exception = re; 3460 _errHandler.reportError(this, re); 3461 _errHandler.recover(this, re); 3462 } 3463 finally { 3464 exitRule(); 3465 } 3466 return _localctx; 3467 } 3468 3469 public static class TdTagCloseContext extends ParserRuleContext { 3470 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3471 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3472 public TerminalNode NEWLINE(int i) { 3473 return getToken(JavadocParser.NEWLINE, i); 3474 } 3475 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3476 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3477 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3478 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3479 public TerminalNode LEADING_ASTERISK(int i) { 3480 return getToken(JavadocParser.LEADING_ASTERISK, i); 3481 } 3482 public TerminalNode WS(int i) { 3483 return getToken(JavadocParser.WS, i); 3484 } 3485 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3486 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3487 super(parent, invokingState); 3488 } 3489 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3490 @Override 3491 public void enterRule(ParseTreeListener listener) { 3492 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3493 } 3494 @Override 3495 public void exitRule(ParseTreeListener listener) { 3496 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3497 } 3498 @Override 3499 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3500 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3501 else return visitor.visitChildren(this); 3502 } 3503 } 3504 3505 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3506 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3507 enterRule(_localctx, 32, RULE_tdTagClose); 3508 int _la; 3509 try { 3510 enterOuterAlt(_localctx, 1); 3511 { 3512 setState(526); match(OPEN); 3513 setState(527); match(SLASH); 3514 setState(528); match(TD_HTML_TAG_NAME); 3515 setState(532); 3516 _errHandler.sync(this); 3517 _la = _input.LA(1); 3518 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3519 { 3520 { 3521 setState(529); 3522 _la = _input.LA(1); 3523 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3524 _errHandler.recoverInline(this); 3525 } 3526 consume(); 3527 } 3528 } 3529 setState(534); 3530 _errHandler.sync(this); 3531 _la = _input.LA(1); 3532 } 3533 setState(535); match(CLOSE); 3534 } 3535 } 3536 catch (RecognitionException re) { 3537 _localctx.exception = re; 3538 _errHandler.reportError(this, re); 3539 _errHandler.recover(this, re); 3540 } 3541 finally { 3542 exitRule(); 3543 } 3544 return _localctx; 3545 } 3546 3547 public static class TdContext extends ParserRuleContext { 3548 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3549 return getRuleContexts(ColgroupTagOpenContext.class); 3550 } 3551 public TbodyContext tbody(int i) { 3552 return getRuleContext(TbodyContext.class,i); 3553 } 3554 public TerminalNode CDATA(int i) { 3555 return getToken(JavadocParser.CDATA, i); 3556 } 3557 public TfootTagOpenContext tfootTagOpen(int i) { 3558 return getRuleContext(TfootTagOpenContext.class,i); 3559 } 3560 public List<DtTagOpenContext> dtTagOpen() { 3561 return getRuleContexts(DtTagOpenContext.class); 3562 } 3563 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3564 public List<ColgroupContext> colgroup() { 3565 return getRuleContexts(ColgroupContext.class); 3566 } 3567 public HeadContext head(int i) { 3568 return getRuleContext(HeadContext.class,i); 3569 } 3570 public List<TrContext> tr() { 3571 return getRuleContexts(TrContext.class); 3572 } 3573 public List<LiContext> li() { 3574 return getRuleContexts(LiContext.class); 3575 } 3576 public ThTagOpenContext thTagOpen(int i) { 3577 return getRuleContext(ThTagOpenContext.class,i); 3578 } 3579 public List<DdTagOpenContext> ddTagOpen() { 3580 return getRuleContexts(DdTagOpenContext.class); 3581 } 3582 public ColgroupContext colgroup(int i) { 3583 return getRuleContext(ColgroupContext.class,i); 3584 } 3585 public TdTagOpenContext tdTagOpen(int i) { 3586 return getRuleContext(TdTagOpenContext.class,i); 3587 } 3588 public List<ThTagOpenContext> thTagOpen() { 3589 return getRuleContexts(ThTagOpenContext.class); 3590 } 3591 public List<HeadTagOpenContext> headTagOpen() { 3592 return getRuleContexts(HeadTagOpenContext.class); 3593 } 3594 public List<HtmlTagOpenContext> htmlTagOpen() { 3595 return getRuleContexts(HtmlTagOpenContext.class); 3596 } 3597 public List<TbodyTagOpenContext> tbodyTagOpen() { 3598 return getRuleContexts(TbodyTagOpenContext.class); 3599 } 3600 public List<TheadContext> thead() { 3601 return getRuleContexts(TheadContext.class); 3602 } 3603 public LiContext li(int i) { 3604 return getRuleContext(LiContext.class,i); 3605 } 3606 public List<TfootTagOpenContext> tfootTagOpen() { 3607 return getRuleContexts(TfootTagOpenContext.class); 3608 } 3609 public List<TfootContext> tfoot() { 3610 return getRuleContexts(TfootContext.class); 3611 } 3612 public List<JavadocInlineTagContext> javadocInlineTag() { 3613 return getRuleContexts(JavadocInlineTagContext.class); 3614 } 3615 public List<HtmlCommentContext> htmlComment() { 3616 return getRuleContexts(HtmlCommentContext.class); 3617 } 3618 public OptionContext option(int i) { 3619 return getRuleContext(OptionContext.class,i); 3620 } 3621 public TrContext tr(int i) { 3622 return getRuleContext(TrContext.class,i); 3623 } 3624 public List<DtContext> dt() { 3625 return getRuleContexts(DtContext.class); 3626 } 3627 public HtmlCommentContext htmlComment(int i) { 3628 return getRuleContext(HtmlCommentContext.class,i); 3629 } 3630 public List<BodyTagOpenContext> bodyTagOpen() { 3631 return getRuleContexts(BodyTagOpenContext.class); 3632 } 3633 public DtTagOpenContext dtTagOpen(int i) { 3634 return getRuleContext(DtTagOpenContext.class,i); 3635 } 3636 public HtmlContext html(int i) { 3637 return getRuleContext(HtmlContext.class,i); 3638 } 3639 public BodyTagOpenContext bodyTagOpen(int i) { 3640 return getRuleContext(BodyTagOpenContext.class,i); 3641 } 3642 public DdTagOpenContext ddTagOpen(int i) { 3643 return getRuleContext(DdTagOpenContext.class,i); 3644 } 3645 public List<TdTagOpenContext> tdTagOpen() { 3646 return getRuleContexts(TdTagOpenContext.class); 3647 } 3648 public List<HtmlTagContext> htmlTag() { 3649 return getRuleContexts(HtmlTagContext.class); 3650 } 3651 public ParagraphContext paragraph(int i) { 3652 return getRuleContext(ParagraphContext.class,i); 3653 } 3654 public OptionTagOpenContext optionTagOpen(int i) { 3655 return getRuleContext(OptionTagOpenContext.class,i); 3656 } 3657 public LiTagOpenContext liTagOpen(int i) { 3658 return getRuleContext(LiTagOpenContext.class,i); 3659 } 3660 public List<ParagraphContext> paragraph() { 3661 return getRuleContexts(ParagraphContext.class); 3662 } 3663 public HtmlTagContext htmlTag(int i) { 3664 return getRuleContext(HtmlTagContext.class,i); 3665 } 3666 public List<SingletonTagContext> singletonTag() { 3667 return getRuleContexts(SingletonTagContext.class); 3668 } 3669 public HeadTagOpenContext headTagOpen(int i) { 3670 return getRuleContext(HeadTagOpenContext.class,i); 3671 } 3672 public List<HtmlContext> html() { 3673 return getRuleContexts(HtmlContext.class); 3674 } 3675 public JavadocInlineTagContext javadocInlineTag(int i) { 3676 return getRuleContext(JavadocInlineTagContext.class,i); 3677 } 3678 public List<ThContext> th() { 3679 return getRuleContexts(ThContext.class); 3680 } 3681 public DtContext dt(int i) { 3682 return getRuleContext(DtContext.class,i); 3683 } 3684 public PTagOpenContext pTagOpen(int i) { 3685 return getRuleContext(PTagOpenContext.class,i); 3686 } 3687 public TerminalNode LEADING_ASTERISK(int i) { 3688 return getToken(JavadocParser.LEADING_ASTERISK, i); 3689 } 3690 public List<TbodyContext> tbody() { 3691 return getRuleContexts(TbodyContext.class); 3692 } 3693 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3694 public List<TheadTagOpenContext> theadTagOpen() { 3695 return getRuleContexts(TheadTagOpenContext.class); 3696 } 3697 public List<HeadContext> head() { 3698 return getRuleContexts(HeadContext.class); 3699 } 3700 public TerminalNode NEWLINE(int i) { 3701 return getToken(JavadocParser.NEWLINE, i); 3702 } 3703 public TextContext text(int i) { 3704 return getRuleContext(TextContext.class,i); 3705 } 3706 public List<BodyContext> body() { 3707 return getRuleContexts(BodyContext.class); 3708 } 3709 public List<OptionTagOpenContext> optionTagOpen() { 3710 return getRuleContexts(OptionTagOpenContext.class); 3711 } 3712 public List<TextContext> text() { 3713 return getRuleContexts(TextContext.class); 3714 } 3715 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3716 public TbodyTagOpenContext tbodyTagOpen(int i) { 3717 return getRuleContext(TbodyTagOpenContext.class,i); 3718 } 3719 public List<DdContext> dd() { 3720 return getRuleContexts(DdContext.class); 3721 } 3722 public TheadTagOpenContext theadTagOpen(int i) { 3723 return getRuleContext(TheadTagOpenContext.class,i); 3724 } 3725 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3726 return getRuleContext(ColgroupTagOpenContext.class,i); 3727 } 3728 public TdTagCloseContext tdTagClose() { 3729 return getRuleContext(TdTagCloseContext.class,0); 3730 } 3731 public List<LiTagOpenContext> liTagOpen() { 3732 return getRuleContexts(LiTagOpenContext.class); 3733 } 3734 public DdContext dd(int i) { 3735 return getRuleContext(DdContext.class,i); 3736 } 3737 public List<OptionContext> option() { 3738 return getRuleContexts(OptionContext.class); 3739 } 3740 public TheadContext thead(int i) { 3741 return getRuleContext(TheadContext.class,i); 3742 } 3743 public BodyContext body(int i) { 3744 return getRuleContext(BodyContext.class,i); 3745 } 3746 public ThContext th(int i) { 3747 return getRuleContext(ThContext.class,i); 3748 } 3749 public List<PTagOpenContext> pTagOpen() { 3750 return getRuleContexts(PTagOpenContext.class); 3751 } 3752 public HtmlTagOpenContext htmlTagOpen(int i) { 3753 return getRuleContext(HtmlTagOpenContext.class,i); 3754 } 3755 public SingletonTagContext singletonTag(int i) { 3756 return getRuleContext(SingletonTagContext.class,i); 3757 } 3758 public TfootContext tfoot(int i) { 3759 return getRuleContext(TfootContext.class,i); 3760 } 3761 public TdContext(ParserRuleContext parent, int invokingState) { 3762 super(parent, invokingState); 3763 } 3764 @Override public int getRuleIndex() { return RULE_td; } 3765 @Override 3766 public void enterRule(ParseTreeListener listener) { 3767 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3768 } 3769 @Override 3770 public void exitRule(ParseTreeListener listener) { 3771 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3772 } 3773 @Override 3774 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3775 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3776 else return visitor.visitChildren(this); 3777 } 3778 } 3779 3780 public final TdContext td() throws RecognitionException { 3781 TdContext _localctx = new TdContext(_ctx, getState()); 3782 enterRule(_localctx, 34, RULE_td); 3783 try { 3784 int _alt; 3785 enterOuterAlt(_localctx, 1); 3786 { 3787 setState(537); tdTagOpen(); 3788 setState(577); 3789 _errHandler.sync(this); 3790 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3791 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3792 if ( _alt==1 ) { 3793 { 3794 setState(575); 3795 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3796 case 1: 3797 { 3798 setState(538); htmlTag(); 3799 } 3800 break; 3801 3802 case 2: 3803 { 3804 setState(539); singletonTag(); 3805 } 3806 break; 3807 3808 case 3: 3809 { 3810 setState(540); paragraph(); 3811 } 3812 break; 3813 3814 case 4: 3815 { 3816 setState(541); li(); 3817 } 3818 break; 3819 3820 case 5: 3821 { 3822 setState(542); tr(); 3823 } 3824 break; 3825 3826 case 6: 3827 { 3828 setState(543); th(); 3829 } 3830 break; 3831 3832 case 7: 3833 { 3834 setState(544); body(); 3835 } 3836 break; 3837 3838 case 8: 3839 { 3840 setState(545); colgroup(); 3841 } 3842 break; 3843 3844 case 9: 3845 { 3846 setState(546); dd(); 3847 } 3848 break; 3849 3850 case 10: 3851 { 3852 setState(547); dt(); 3853 } 3854 break; 3855 3856 case 11: 3857 { 3858 setState(548); head(); 3859 } 3860 break; 3861 3862 case 12: 3863 { 3864 setState(549); html(); 3865 } 3866 break; 3867 3868 case 13: 3869 { 3870 setState(550); option(); 3871 } 3872 break; 3873 3874 case 14: 3875 { 3876 setState(551); tbody(); 3877 } 3878 break; 3879 3880 case 15: 3881 { 3882 setState(552); thead(); 3883 } 3884 break; 3885 3886 case 16: 3887 { 3888 setState(553); tfoot(); 3889 } 3890 break; 3891 3892 case 17: 3893 { 3894 setState(554); pTagOpen(); 3895 } 3896 break; 3897 3898 case 18: 3899 { 3900 setState(555); liTagOpen(); 3901 } 3902 break; 3903 3904 case 19: 3905 { 3906 setState(556); tdTagOpen(); 3907 } 3908 break; 3909 3910 case 20: 3911 { 3912 setState(557); thTagOpen(); 3913 } 3914 break; 3915 3916 case 21: 3917 { 3918 setState(558); bodyTagOpen(); 3919 } 3920 break; 3921 3922 case 22: 3923 { 3924 setState(559); colgroupTagOpen(); 3925 } 3926 break; 3927 3928 case 23: 3929 { 3930 setState(560); ddTagOpen(); 3931 } 3932 break; 3933 3934 case 24: 3935 { 3936 setState(561); dtTagOpen(); 3937 } 3938 break; 3939 3940 case 25: 3941 { 3942 setState(562); headTagOpen(); 3943 } 3944 break; 3945 3946 case 26: 3947 { 3948 setState(563); htmlTagOpen(); 3949 } 3950 break; 3951 3952 case 27: 3953 { 3954 setState(564); optionTagOpen(); 3955 } 3956 break; 3957 3958 case 28: 3959 { 3960 setState(565); tbodyTagOpen(); 3961 } 3962 break; 3963 3964 case 29: 3965 { 3966 setState(566); theadTagOpen(); 3967 } 3968 break; 3969 3970 case 30: 3971 { 3972 setState(567); tfootTagOpen(); 3973 } 3974 break; 3975 3976 case 31: 3977 { 3978 { 3979 setState(568); 3980 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3981 setState(569); match(LEADING_ASTERISK); 3982 } 3983 } 3984 break; 3985 3986 case 32: 3987 { 3988 setState(570); htmlComment(); 3989 } 3990 break; 3991 3992 case 33: 3993 { 3994 setState(571); match(CDATA); 3995 } 3996 break; 3997 3998 case 34: 3999 { 4000 setState(572); match(NEWLINE); 4001 } 4002 break; 4003 4004 case 35: 4005 { 4006 setState(573); text(); 4007 } 4008 break; 4009 4010 case 36: 4011 { 4012 setState(574); javadocInlineTag(); 4013 } 4014 break; 4015 } 4016 } 4017 } 4018 setState(579); 4019 _errHandler.sync(this); 4020 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4021 } 4022 setState(580); tdTagClose(); 4023 } 4024 } 4025 catch (RecognitionException re) { 4026 _localctx.exception = re; 4027 _errHandler.reportError(this, re); 4028 _errHandler.recover(this, re); 4029 } 4030 finally { 4031 exitRule(); 4032 } 4033 return _localctx; 4034 } 4035 4036 public static class ThTagOpenContext extends ParserRuleContext { 4037 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4038 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4039 public TerminalNode NEWLINE(int i) { 4040 return getToken(JavadocParser.NEWLINE, i); 4041 } 4042 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4043 public List<AttributeContext> attribute() { 4044 return getRuleContexts(AttributeContext.class); 4045 } 4046 public AttributeContext attribute(int i) { 4047 return getRuleContext(AttributeContext.class,i); 4048 } 4049 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4050 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4051 public TerminalNode LEADING_ASTERISK(int i) { 4052 return getToken(JavadocParser.LEADING_ASTERISK, i); 4053 } 4054 public TerminalNode WS(int i) { 4055 return getToken(JavadocParser.WS, i); 4056 } 4057 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4058 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4059 super(parent, invokingState); 4060 } 4061 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4062 @Override 4063 public void enterRule(ParseTreeListener listener) { 4064 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4065 } 4066 @Override 4067 public void exitRule(ParseTreeListener listener) { 4068 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4069 } 4070 @Override 4071 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4072 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4073 else return visitor.visitChildren(this); 4074 } 4075 } 4076 4077 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4078 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4079 enterRule(_localctx, 36, RULE_thTagOpen); 4080 int _la; 4081 try { 4082 enterOuterAlt(_localctx, 1); 4083 { 4084 setState(582); match(OPEN); 4085 setState(583); match(TH_HTML_TAG_NAME); 4086 setState(590); 4087 _errHandler.sync(this); 4088 _la = _input.LA(1); 4089 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4090 { 4091 setState(588); 4092 switch (_input.LA(1)) { 4093 case HTML_TAG_NAME: 4094 { 4095 setState(584); attribute(); 4096 } 4097 break; 4098 case NEWLINE: 4099 { 4100 setState(585); match(NEWLINE); 4101 } 4102 break; 4103 case LEADING_ASTERISK: 4104 { 4105 setState(586); match(LEADING_ASTERISK); 4106 } 4107 break; 4108 case WS: 4109 { 4110 setState(587); match(WS); 4111 } 4112 break; 4113 default: 4114 throw new NoViableAltException(this); 4115 } 4116 } 4117 setState(592); 4118 _errHandler.sync(this); 4119 _la = _input.LA(1); 4120 } 4121 setState(593); match(CLOSE); 4122 } 4123 } 4124 catch (RecognitionException re) { 4125 _localctx.exception = re; 4126 _errHandler.reportError(this, re); 4127 _errHandler.recover(this, re); 4128 } 4129 finally { 4130 exitRule(); 4131 } 4132 return _localctx; 4133 } 4134 4135 public static class ThTagCloseContext extends ParserRuleContext { 4136 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4137 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4138 public TerminalNode NEWLINE(int i) { 4139 return getToken(JavadocParser.NEWLINE, i); 4140 } 4141 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4142 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4143 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4144 public TerminalNode LEADING_ASTERISK(int i) { 4145 return getToken(JavadocParser.LEADING_ASTERISK, i); 4146 } 4147 public TerminalNode WS(int i) { 4148 return getToken(JavadocParser.WS, i); 4149 } 4150 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4151 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4152 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4153 super(parent, invokingState); 4154 } 4155 @Override public int getRuleIndex() { return RULE_thTagClose; } 4156 @Override 4157 public void enterRule(ParseTreeListener listener) { 4158 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4159 } 4160 @Override 4161 public void exitRule(ParseTreeListener listener) { 4162 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4163 } 4164 @Override 4165 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4166 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4167 else return visitor.visitChildren(this); 4168 } 4169 } 4170 4171 public final ThTagCloseContext thTagClose() throws RecognitionException { 4172 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4173 enterRule(_localctx, 38, RULE_thTagClose); 4174 int _la; 4175 try { 4176 enterOuterAlt(_localctx, 1); 4177 { 4178 setState(595); match(OPEN); 4179 setState(596); match(SLASH); 4180 setState(597); match(TH_HTML_TAG_NAME); 4181 setState(601); 4182 _errHandler.sync(this); 4183 _la = _input.LA(1); 4184 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4185 { 4186 { 4187 setState(598); 4188 _la = _input.LA(1); 4189 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4190 _errHandler.recoverInline(this); 4191 } 4192 consume(); 4193 } 4194 } 4195 setState(603); 4196 _errHandler.sync(this); 4197 _la = _input.LA(1); 4198 } 4199 setState(604); match(CLOSE); 4200 } 4201 } 4202 catch (RecognitionException re) { 4203 _localctx.exception = re; 4204 _errHandler.reportError(this, re); 4205 _errHandler.recover(this, re); 4206 } 4207 finally { 4208 exitRule(); 4209 } 4210 return _localctx; 4211 } 4212 4213 public static class ThContext extends ParserRuleContext { 4214 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4215 return getRuleContexts(ColgroupTagOpenContext.class); 4216 } 4217 public ThTagCloseContext thTagClose() { 4218 return getRuleContext(ThTagCloseContext.class,0); 4219 } 4220 public TbodyContext tbody(int i) { 4221 return getRuleContext(TbodyContext.class,i); 4222 } 4223 public TerminalNode CDATA(int i) { 4224 return getToken(JavadocParser.CDATA, i); 4225 } 4226 public TfootTagOpenContext tfootTagOpen(int i) { 4227 return getRuleContext(TfootTagOpenContext.class,i); 4228 } 4229 public List<DtTagOpenContext> dtTagOpen() { 4230 return getRuleContexts(DtTagOpenContext.class); 4231 } 4232 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4233 public HeadContext head(int i) { 4234 return getRuleContext(HeadContext.class,i); 4235 } 4236 public List<ColgroupContext> colgroup() { 4237 return getRuleContexts(ColgroupContext.class); 4238 } 4239 public List<TrContext> tr() { 4240 return getRuleContexts(TrContext.class); 4241 } 4242 public List<LiContext> li() { 4243 return getRuleContexts(LiContext.class); 4244 } 4245 public List<DdTagOpenContext> ddTagOpen() { 4246 return getRuleContexts(DdTagOpenContext.class); 4247 } 4248 public ColgroupContext colgroup(int i) { 4249 return getRuleContext(ColgroupContext.class,i); 4250 } 4251 public ThTagOpenContext thTagOpen() { 4252 return getRuleContext(ThTagOpenContext.class,0); 4253 } 4254 public TdTagOpenContext tdTagOpen(int i) { 4255 return getRuleContext(TdTagOpenContext.class,i); 4256 } 4257 public List<HeadTagOpenContext> headTagOpen() { 4258 return getRuleContexts(HeadTagOpenContext.class); 4259 } 4260 public List<HtmlTagOpenContext> htmlTagOpen() { 4261 return getRuleContexts(HtmlTagOpenContext.class); 4262 } 4263 public List<TbodyTagOpenContext> tbodyTagOpen() { 4264 return getRuleContexts(TbodyTagOpenContext.class); 4265 } 4266 public List<TheadContext> thead() { 4267 return getRuleContexts(TheadContext.class); 4268 } 4269 public LiContext li(int i) { 4270 return getRuleContext(LiContext.class,i); 4271 } 4272 public List<TfootTagOpenContext> tfootTagOpen() { 4273 return getRuleContexts(TfootTagOpenContext.class); 4274 } 4275 public List<TfootContext> tfoot() { 4276 return getRuleContexts(TfootContext.class); 4277 } 4278 public List<JavadocInlineTagContext> javadocInlineTag() { 4279 return getRuleContexts(JavadocInlineTagContext.class); 4280 } 4281 public List<HtmlCommentContext> htmlComment() { 4282 return getRuleContexts(HtmlCommentContext.class); 4283 } 4284 public OptionContext option(int i) { 4285 return getRuleContext(OptionContext.class,i); 4286 } 4287 public TrContext tr(int i) { 4288 return getRuleContext(TrContext.class,i); 4289 } 4290 public List<DtContext> dt() { 4291 return getRuleContexts(DtContext.class); 4292 } 4293 public HtmlCommentContext htmlComment(int i) { 4294 return getRuleContext(HtmlCommentContext.class,i); 4295 } 4296 public List<TdContext> td() { 4297 return getRuleContexts(TdContext.class); 4298 } 4299 public List<BodyTagOpenContext> bodyTagOpen() { 4300 return getRuleContexts(BodyTagOpenContext.class); 4301 } 4302 public DtTagOpenContext dtTagOpen(int i) { 4303 return getRuleContext(DtTagOpenContext.class,i); 4304 } 4305 public HtmlContext html(int i) { 4306 return getRuleContext(HtmlContext.class,i); 4307 } 4308 public BodyTagOpenContext bodyTagOpen(int i) { 4309 return getRuleContext(BodyTagOpenContext.class,i); 4310 } 4311 public DdTagOpenContext ddTagOpen(int i) { 4312 return getRuleContext(DdTagOpenContext.class,i); 4313 } 4314 public List<HtmlTagContext> htmlTag() { 4315 return getRuleContexts(HtmlTagContext.class); 4316 } 4317 public ParagraphContext paragraph(int i) { 4318 return getRuleContext(ParagraphContext.class,i); 4319 } 4320 public List<TdTagOpenContext> tdTagOpen() { 4321 return getRuleContexts(TdTagOpenContext.class); 4322 } 4323 public OptionTagOpenContext optionTagOpen(int i) { 4324 return getRuleContext(OptionTagOpenContext.class,i); 4325 } 4326 public LiTagOpenContext liTagOpen(int i) { 4327 return getRuleContext(LiTagOpenContext.class,i); 4328 } 4329 public TdContext td(int i) { 4330 return getRuleContext(TdContext.class,i); 4331 } 4332 public List<ParagraphContext> paragraph() { 4333 return getRuleContexts(ParagraphContext.class); 4334 } 4335 public HtmlTagContext htmlTag(int i) { 4336 return getRuleContext(HtmlTagContext.class,i); 4337 } 4338 public List<SingletonTagContext> singletonTag() { 4339 return getRuleContexts(SingletonTagContext.class); 4340 } 4341 public HeadTagOpenContext headTagOpen(int i) { 4342 return getRuleContext(HeadTagOpenContext.class,i); 4343 } 4344 public TrTagOpenContext trTagOpen(int i) { 4345 return getRuleContext(TrTagOpenContext.class,i); 4346 } 4347 public List<HtmlContext> html() { 4348 return getRuleContexts(HtmlContext.class); 4349 } 4350 public JavadocInlineTagContext javadocInlineTag(int i) { 4351 return getRuleContext(JavadocInlineTagContext.class,i); 4352 } 4353 public DtContext dt(int i) { 4354 return getRuleContext(DtContext.class,i); 4355 } 4356 public PTagOpenContext pTagOpen(int i) { 4357 return getRuleContext(PTagOpenContext.class,i); 4358 } 4359 public TerminalNode LEADING_ASTERISK(int i) { 4360 return getToken(JavadocParser.LEADING_ASTERISK, i); 4361 } 4362 public List<TrTagOpenContext> trTagOpen() { 4363 return getRuleContexts(TrTagOpenContext.class); 4364 } 4365 public List<TbodyContext> tbody() { 4366 return getRuleContexts(TbodyContext.class); 4367 } 4368 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4369 public List<TheadTagOpenContext> theadTagOpen() { 4370 return getRuleContexts(TheadTagOpenContext.class); 4371 } 4372 public List<HeadContext> head() { 4373 return getRuleContexts(HeadContext.class); 4374 } 4375 public TerminalNode NEWLINE(int i) { 4376 return getToken(JavadocParser.NEWLINE, i); 4377 } 4378 public TextContext text(int i) { 4379 return getRuleContext(TextContext.class,i); 4380 } 4381 public List<BodyContext> body() { 4382 return getRuleContexts(BodyContext.class); 4383 } 4384 public List<OptionTagOpenContext> optionTagOpen() { 4385 return getRuleContexts(OptionTagOpenContext.class); 4386 } 4387 public List<TextContext> text() { 4388 return getRuleContexts(TextContext.class); 4389 } 4390 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4391 public TbodyTagOpenContext tbodyTagOpen(int i) { 4392 return getRuleContext(TbodyTagOpenContext.class,i); 4393 } 4394 public List<DdContext> dd() { 4395 return getRuleContexts(DdContext.class); 4396 } 4397 public TheadTagOpenContext theadTagOpen(int i) { 4398 return getRuleContext(TheadTagOpenContext.class,i); 4399 } 4400 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4401 return getRuleContext(ColgroupTagOpenContext.class,i); 4402 } 4403 public List<LiTagOpenContext> liTagOpen() { 4404 return getRuleContexts(LiTagOpenContext.class); 4405 } 4406 public DdContext dd(int i) { 4407 return getRuleContext(DdContext.class,i); 4408 } 4409 public List<OptionContext> option() { 4410 return getRuleContexts(OptionContext.class); 4411 } 4412 public TheadContext thead(int i) { 4413 return getRuleContext(TheadContext.class,i); 4414 } 4415 public BodyContext body(int i) { 4416 return getRuleContext(BodyContext.class,i); 4417 } 4418 public List<PTagOpenContext> pTagOpen() { 4419 return getRuleContexts(PTagOpenContext.class); 4420 } 4421 public HtmlTagOpenContext htmlTagOpen(int i) { 4422 return getRuleContext(HtmlTagOpenContext.class,i); 4423 } 4424 public SingletonTagContext singletonTag(int i) { 4425 return getRuleContext(SingletonTagContext.class,i); 4426 } 4427 public TfootContext tfoot(int i) { 4428 return getRuleContext(TfootContext.class,i); 4429 } 4430 public ThContext(ParserRuleContext parent, int invokingState) { 4431 super(parent, invokingState); 4432 } 4433 @Override public int getRuleIndex() { return RULE_th; } 4434 @Override 4435 public void enterRule(ParseTreeListener listener) { 4436 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4437 } 4438 @Override 4439 public void exitRule(ParseTreeListener listener) { 4440 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4441 } 4442 @Override 4443 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4444 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4445 else return visitor.visitChildren(this); 4446 } 4447 } 4448 4449 public final ThContext th() throws RecognitionException { 4450 ThContext _localctx = new ThContext(_ctx, getState()); 4451 enterRule(_localctx, 40, RULE_th); 4452 try { 4453 int _alt; 4454 enterOuterAlt(_localctx, 1); 4455 { 4456 setState(606); thTagOpen(); 4457 setState(646); 4458 _errHandler.sync(this); 4459 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4460 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4461 if ( _alt==1 ) { 4462 { 4463 setState(644); 4464 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4465 case 1: 4466 { 4467 setState(607); htmlTag(); 4468 } 4469 break; 4470 4471 case 2: 4472 { 4473 setState(608); singletonTag(); 4474 } 4475 break; 4476 4477 case 3: 4478 { 4479 setState(609); paragraph(); 4480 } 4481 break; 4482 4483 case 4: 4484 { 4485 setState(610); li(); 4486 } 4487 break; 4488 4489 case 5: 4490 { 4491 setState(611); tr(); 4492 } 4493 break; 4494 4495 case 6: 4496 { 4497 setState(612); td(); 4498 } 4499 break; 4500 4501 case 7: 4502 { 4503 setState(613); body(); 4504 } 4505 break; 4506 4507 case 8: 4508 { 4509 setState(614); colgroup(); 4510 } 4511 break; 4512 4513 case 9: 4514 { 4515 setState(615); dd(); 4516 } 4517 break; 4518 4519 case 10: 4520 { 4521 setState(616); dt(); 4522 } 4523 break; 4524 4525 case 11: 4526 { 4527 setState(617); head(); 4528 } 4529 break; 4530 4531 case 12: 4532 { 4533 setState(618); html(); 4534 } 4535 break; 4536 4537 case 13: 4538 { 4539 setState(619); option(); 4540 } 4541 break; 4542 4543 case 14: 4544 { 4545 setState(620); tbody(); 4546 } 4547 break; 4548 4549 case 15: 4550 { 4551 setState(621); thead(); 4552 } 4553 break; 4554 4555 case 16: 4556 { 4557 setState(622); tfoot(); 4558 } 4559 break; 4560 4561 case 17: 4562 { 4563 setState(623); pTagOpen(); 4564 } 4565 break; 4566 4567 case 18: 4568 { 4569 setState(624); liTagOpen(); 4570 } 4571 break; 4572 4573 case 19: 4574 { 4575 setState(625); trTagOpen(); 4576 } 4577 break; 4578 4579 case 20: 4580 { 4581 setState(626); tdTagOpen(); 4582 } 4583 break; 4584 4585 case 21: 4586 { 4587 setState(627); bodyTagOpen(); 4588 } 4589 break; 4590 4591 case 22: 4592 { 4593 setState(628); colgroupTagOpen(); 4594 } 4595 break; 4596 4597 case 23: 4598 { 4599 setState(629); ddTagOpen(); 4600 } 4601 break; 4602 4603 case 24: 4604 { 4605 setState(630); dtTagOpen(); 4606 } 4607 break; 4608 4609 case 25: 4610 { 4611 setState(631); headTagOpen(); 4612 } 4613 break; 4614 4615 case 26: 4616 { 4617 setState(632); htmlTagOpen(); 4618 } 4619 break; 4620 4621 case 27: 4622 { 4623 setState(633); optionTagOpen(); 4624 } 4625 break; 4626 4627 case 28: 4628 { 4629 setState(634); tbodyTagOpen(); 4630 } 4631 break; 4632 4633 case 29: 4634 { 4635 setState(635); theadTagOpen(); 4636 } 4637 break; 4638 4639 case 30: 4640 { 4641 setState(636); tfootTagOpen(); 4642 } 4643 break; 4644 4645 case 31: 4646 { 4647 { 4648 setState(637); 4649 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4650 setState(638); match(LEADING_ASTERISK); 4651 } 4652 } 4653 break; 4654 4655 case 32: 4656 { 4657 setState(639); htmlComment(); 4658 } 4659 break; 4660 4661 case 33: 4662 { 4663 setState(640); match(CDATA); 4664 } 4665 break; 4666 4667 case 34: 4668 { 4669 setState(641); match(NEWLINE); 4670 } 4671 break; 4672 4673 case 35: 4674 { 4675 setState(642); text(); 4676 } 4677 break; 4678 4679 case 36: 4680 { 4681 setState(643); javadocInlineTag(); 4682 } 4683 break; 4684 } 4685 } 4686 } 4687 setState(648); 4688 _errHandler.sync(this); 4689 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4690 } 4691 setState(649); thTagClose(); 4692 } 4693 } 4694 catch (RecognitionException re) { 4695 _localctx.exception = re; 4696 _errHandler.reportError(this, re); 4697 _errHandler.recover(this, re); 4698 } 4699 finally { 4700 exitRule(); 4701 } 4702 return _localctx; 4703 } 4704 4705 public static class BodyTagOpenContext extends ParserRuleContext { 4706 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4707 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4708 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4709 public TerminalNode NEWLINE(int i) { 4710 return getToken(JavadocParser.NEWLINE, i); 4711 } 4712 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4713 public List<AttributeContext> attribute() { 4714 return getRuleContexts(AttributeContext.class); 4715 } 4716 public AttributeContext attribute(int i) { 4717 return getRuleContext(AttributeContext.class,i); 4718 } 4719 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4720 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4721 public TerminalNode LEADING_ASTERISK(int i) { 4722 return getToken(JavadocParser.LEADING_ASTERISK, i); 4723 } 4724 public TerminalNode WS(int i) { 4725 return getToken(JavadocParser.WS, i); 4726 } 4727 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4728 super(parent, invokingState); 4729 } 4730 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4731 @Override 4732 public void enterRule(ParseTreeListener listener) { 4733 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4734 } 4735 @Override 4736 public void exitRule(ParseTreeListener listener) { 4737 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4738 } 4739 @Override 4740 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4741 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4742 else return visitor.visitChildren(this); 4743 } 4744 } 4745 4746 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4747 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4748 enterRule(_localctx, 42, RULE_bodyTagOpen); 4749 int _la; 4750 try { 4751 enterOuterAlt(_localctx, 1); 4752 { 4753 setState(651); match(OPEN); 4754 setState(652); match(BODY_HTML_TAG_NAME); 4755 setState(659); 4756 _errHandler.sync(this); 4757 _la = _input.LA(1); 4758 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4759 { 4760 setState(657); 4761 switch (_input.LA(1)) { 4762 case HTML_TAG_NAME: 4763 { 4764 setState(653); attribute(); 4765 } 4766 break; 4767 case NEWLINE: 4768 { 4769 setState(654); match(NEWLINE); 4770 } 4771 break; 4772 case LEADING_ASTERISK: 4773 { 4774 setState(655); match(LEADING_ASTERISK); 4775 } 4776 break; 4777 case WS: 4778 { 4779 setState(656); match(WS); 4780 } 4781 break; 4782 default: 4783 throw new NoViableAltException(this); 4784 } 4785 } 4786 setState(661); 4787 _errHandler.sync(this); 4788 _la = _input.LA(1); 4789 } 4790 setState(662); match(CLOSE); 4791 } 4792 } 4793 catch (RecognitionException re) { 4794 _localctx.exception = re; 4795 _errHandler.reportError(this, re); 4796 _errHandler.recover(this, re); 4797 } 4798 finally { 4799 exitRule(); 4800 } 4801 return _localctx; 4802 } 4803 4804 public static class BodyTagCloseContext extends ParserRuleContext { 4805 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4806 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4807 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4808 public TerminalNode NEWLINE(int i) { 4809 return getToken(JavadocParser.NEWLINE, i); 4810 } 4811 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4812 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4813 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4814 public TerminalNode LEADING_ASTERISK(int i) { 4815 return getToken(JavadocParser.LEADING_ASTERISK, i); 4816 } 4817 public TerminalNode WS(int i) { 4818 return getToken(JavadocParser.WS, i); 4819 } 4820 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4821 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 4822 super(parent, invokingState); 4823 } 4824 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 4825 @Override 4826 public void enterRule(ParseTreeListener listener) { 4827 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 4828 } 4829 @Override 4830 public void exitRule(ParseTreeListener listener) { 4831 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 4832 } 4833 @Override 4834 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4835 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 4836 else return visitor.visitChildren(this); 4837 } 4838 } 4839 4840 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 4841 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 4842 enterRule(_localctx, 44, RULE_bodyTagClose); 4843 int _la; 4844 try { 4845 enterOuterAlt(_localctx, 1); 4846 { 4847 setState(664); match(OPEN); 4848 setState(665); match(SLASH); 4849 setState(666); match(BODY_HTML_TAG_NAME); 4850 setState(670); 4851 _errHandler.sync(this); 4852 _la = _input.LA(1); 4853 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4854 { 4855 { 4856 setState(667); 4857 _la = _input.LA(1); 4858 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4859 _errHandler.recoverInline(this); 4860 } 4861 consume(); 4862 } 4863 } 4864 setState(672); 4865 _errHandler.sync(this); 4866 _la = _input.LA(1); 4867 } 4868 setState(673); match(CLOSE); 4869 } 4870 } 4871 catch (RecognitionException re) { 4872 _localctx.exception = re; 4873 _errHandler.reportError(this, re); 4874 _errHandler.recover(this, re); 4875 } 4876 finally { 4877 exitRule(); 4878 } 4879 return _localctx; 4880 } 4881 4882 public static class BodyContext extends ParserRuleContext { 4883 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4884 return getRuleContexts(ColgroupTagOpenContext.class); 4885 } 4886 public TbodyContext tbody(int i) { 4887 return getRuleContext(TbodyContext.class,i); 4888 } 4889 public TerminalNode CDATA(int i) { 4890 return getToken(JavadocParser.CDATA, i); 4891 } 4892 public TfootTagOpenContext tfootTagOpen(int i) { 4893 return getRuleContext(TfootTagOpenContext.class,i); 4894 } 4895 public List<DtTagOpenContext> dtTagOpen() { 4896 return getRuleContexts(DtTagOpenContext.class); 4897 } 4898 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4899 public HeadContext head(int i) { 4900 return getRuleContext(HeadContext.class,i); 4901 } 4902 public List<ColgroupContext> colgroup() { 4903 return getRuleContexts(ColgroupContext.class); 4904 } 4905 public List<TrContext> tr() { 4906 return getRuleContexts(TrContext.class); 4907 } 4908 public List<LiContext> li() { 4909 return getRuleContexts(LiContext.class); 4910 } 4911 public ThTagOpenContext thTagOpen(int i) { 4912 return getRuleContext(ThTagOpenContext.class,i); 4913 } 4914 public List<DdTagOpenContext> ddTagOpen() { 4915 return getRuleContexts(DdTagOpenContext.class); 4916 } 4917 public ColgroupContext colgroup(int i) { 4918 return getRuleContext(ColgroupContext.class,i); 4919 } 4920 public TdTagOpenContext tdTagOpen(int i) { 4921 return getRuleContext(TdTagOpenContext.class,i); 4922 } 4923 public List<ThTagOpenContext> thTagOpen() { 4924 return getRuleContexts(ThTagOpenContext.class); 4925 } 4926 public List<HeadTagOpenContext> headTagOpen() { 4927 return getRuleContexts(HeadTagOpenContext.class); 4928 } 4929 public List<HtmlTagOpenContext> htmlTagOpen() { 4930 return getRuleContexts(HtmlTagOpenContext.class); 4931 } 4932 public List<TbodyTagOpenContext> tbodyTagOpen() { 4933 return getRuleContexts(TbodyTagOpenContext.class); 4934 } 4935 public List<TheadContext> thead() { 4936 return getRuleContexts(TheadContext.class); 4937 } 4938 public LiContext li(int i) { 4939 return getRuleContext(LiContext.class,i); 4940 } 4941 public List<TfootTagOpenContext> tfootTagOpen() { 4942 return getRuleContexts(TfootTagOpenContext.class); 4943 } 4944 public List<TfootContext> tfoot() { 4945 return getRuleContexts(TfootContext.class); 4946 } 4947 public List<JavadocInlineTagContext> javadocInlineTag() { 4948 return getRuleContexts(JavadocInlineTagContext.class); 4949 } 4950 public List<HtmlCommentContext> htmlComment() { 4951 return getRuleContexts(HtmlCommentContext.class); 4952 } 4953 public OptionContext option(int i) { 4954 return getRuleContext(OptionContext.class,i); 4955 } 4956 public BodyTagCloseContext bodyTagClose() { 4957 return getRuleContext(BodyTagCloseContext.class,0); 4958 } 4959 public TrContext tr(int i) { 4960 return getRuleContext(TrContext.class,i); 4961 } 4962 public List<DtContext> dt() { 4963 return getRuleContexts(DtContext.class); 4964 } 4965 public HtmlCommentContext htmlComment(int i) { 4966 return getRuleContext(HtmlCommentContext.class,i); 4967 } 4968 public List<TdContext> td() { 4969 return getRuleContexts(TdContext.class); 4970 } 4971 public BodyTagOpenContext bodyTagOpen() { 4972 return getRuleContext(BodyTagOpenContext.class,0); 4973 } 4974 public DtTagOpenContext dtTagOpen(int i) { 4975 return getRuleContext(DtTagOpenContext.class,i); 4976 } 4977 public HtmlContext html(int i) { 4978 return getRuleContext(HtmlContext.class,i); 4979 } 4980 public DdTagOpenContext ddTagOpen(int i) { 4981 return getRuleContext(DdTagOpenContext.class,i); 4982 } 4983 public List<HtmlTagContext> htmlTag() { 4984 return getRuleContexts(HtmlTagContext.class); 4985 } 4986 public ParagraphContext paragraph(int i) { 4987 return getRuleContext(ParagraphContext.class,i); 4988 } 4989 public List<TdTagOpenContext> tdTagOpen() { 4990 return getRuleContexts(TdTagOpenContext.class); 4991 } 4992 public OptionTagOpenContext optionTagOpen(int i) { 4993 return getRuleContext(OptionTagOpenContext.class,i); 4994 } 4995 public LiTagOpenContext liTagOpen(int i) { 4996 return getRuleContext(LiTagOpenContext.class,i); 4997 } 4998 public TdContext td(int i) { 4999 return getRuleContext(TdContext.class,i); 5000 } 5001 public List<ParagraphContext> paragraph() { 5002 return getRuleContexts(ParagraphContext.class); 5003 } 5004 public HtmlTagContext htmlTag(int i) { 5005 return getRuleContext(HtmlTagContext.class,i); 5006 } 5007 public List<SingletonTagContext> singletonTag() { 5008 return getRuleContexts(SingletonTagContext.class); 5009 } 5010 public HeadTagOpenContext headTagOpen(int i) { 5011 return getRuleContext(HeadTagOpenContext.class,i); 5012 } 5013 public TrTagOpenContext trTagOpen(int i) { 5014 return getRuleContext(TrTagOpenContext.class,i); 5015 } 5016 public List<HtmlContext> html() { 5017 return getRuleContexts(HtmlContext.class); 5018 } 5019 public JavadocInlineTagContext javadocInlineTag(int i) { 5020 return getRuleContext(JavadocInlineTagContext.class,i); 5021 } 5022 public List<ThContext> th() { 5023 return getRuleContexts(ThContext.class); 5024 } 5025 public DtContext dt(int i) { 5026 return getRuleContext(DtContext.class,i); 5027 } 5028 public PTagOpenContext pTagOpen(int i) { 5029 return getRuleContext(PTagOpenContext.class,i); 5030 } 5031 public TerminalNode LEADING_ASTERISK(int i) { 5032 return getToken(JavadocParser.LEADING_ASTERISK, i); 5033 } 5034 public List<TrTagOpenContext> trTagOpen() { 5035 return getRuleContexts(TrTagOpenContext.class); 5036 } 5037 public List<TbodyContext> tbody() { 5038 return getRuleContexts(TbodyContext.class); 5039 } 5040 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5041 public List<TheadTagOpenContext> theadTagOpen() { 5042 return getRuleContexts(TheadTagOpenContext.class); 5043 } 5044 public List<HeadContext> head() { 5045 return getRuleContexts(HeadContext.class); 5046 } 5047 public TerminalNode NEWLINE(int i) { 5048 return getToken(JavadocParser.NEWLINE, i); 5049 } 5050 public TextContext text(int i) { 5051 return getRuleContext(TextContext.class,i); 5052 } 5053 public List<OptionTagOpenContext> optionTagOpen() { 5054 return getRuleContexts(OptionTagOpenContext.class); 5055 } 5056 public List<TextContext> text() { 5057 return getRuleContexts(TextContext.class); 5058 } 5059 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5060 public TbodyTagOpenContext tbodyTagOpen(int i) { 5061 return getRuleContext(TbodyTagOpenContext.class,i); 5062 } 5063 public List<DdContext> dd() { 5064 return getRuleContexts(DdContext.class); 5065 } 5066 public TheadTagOpenContext theadTagOpen(int i) { 5067 return getRuleContext(TheadTagOpenContext.class,i); 5068 } 5069 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5070 return getRuleContext(ColgroupTagOpenContext.class,i); 5071 } 5072 public List<LiTagOpenContext> liTagOpen() { 5073 return getRuleContexts(LiTagOpenContext.class); 5074 } 5075 public DdContext dd(int i) { 5076 return getRuleContext(DdContext.class,i); 5077 } 5078 public List<OptionContext> option() { 5079 return getRuleContexts(OptionContext.class); 5080 } 5081 public TheadContext thead(int i) { 5082 return getRuleContext(TheadContext.class,i); 5083 } 5084 public ThContext th(int i) { 5085 return getRuleContext(ThContext.class,i); 5086 } 5087 public List<PTagOpenContext> pTagOpen() { 5088 return getRuleContexts(PTagOpenContext.class); 5089 } 5090 public HtmlTagOpenContext htmlTagOpen(int i) { 5091 return getRuleContext(HtmlTagOpenContext.class,i); 5092 } 5093 public SingletonTagContext singletonTag(int i) { 5094 return getRuleContext(SingletonTagContext.class,i); 5095 } 5096 public TfootContext tfoot(int i) { 5097 return getRuleContext(TfootContext.class,i); 5098 } 5099 public BodyContext(ParserRuleContext parent, int invokingState) { 5100 super(parent, invokingState); 5101 } 5102 @Override public int getRuleIndex() { return RULE_body; } 5103 @Override 5104 public void enterRule(ParseTreeListener listener) { 5105 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5106 } 5107 @Override 5108 public void exitRule(ParseTreeListener listener) { 5109 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5110 } 5111 @Override 5112 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5113 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5114 else return visitor.visitChildren(this); 5115 } 5116 } 5117 5118 public final BodyContext body() throws RecognitionException { 5119 BodyContext _localctx = new BodyContext(_ctx, getState()); 5120 enterRule(_localctx, 46, RULE_body); 5121 try { 5122 int _alt; 5123 enterOuterAlt(_localctx, 1); 5124 { 5125 setState(675); bodyTagOpen(); 5126 setState(715); 5127 _errHandler.sync(this); 5128 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5129 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5130 if ( _alt==1 ) { 5131 { 5132 setState(713); 5133 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5134 case 1: 5135 { 5136 setState(676); htmlTag(); 5137 } 5138 break; 5139 5140 case 2: 5141 { 5142 setState(677); singletonTag(); 5143 } 5144 break; 5145 5146 case 3: 5147 { 5148 setState(678); paragraph(); 5149 } 5150 break; 5151 5152 case 4: 5153 { 5154 setState(679); li(); 5155 } 5156 break; 5157 5158 case 5: 5159 { 5160 setState(680); tr(); 5161 } 5162 break; 5163 5164 case 6: 5165 { 5166 setState(681); td(); 5167 } 5168 break; 5169 5170 case 7: 5171 { 5172 setState(682); th(); 5173 } 5174 break; 5175 5176 case 8: 5177 { 5178 setState(683); colgroup(); 5179 } 5180 break; 5181 5182 case 9: 5183 { 5184 setState(684); dd(); 5185 } 5186 break; 5187 5188 case 10: 5189 { 5190 setState(685); dt(); 5191 } 5192 break; 5193 5194 case 11: 5195 { 5196 setState(686); head(); 5197 } 5198 break; 5199 5200 case 12: 5201 { 5202 setState(687); html(); 5203 } 5204 break; 5205 5206 case 13: 5207 { 5208 setState(688); option(); 5209 } 5210 break; 5211 5212 case 14: 5213 { 5214 setState(689); tbody(); 5215 } 5216 break; 5217 5218 case 15: 5219 { 5220 setState(690); thead(); 5221 } 5222 break; 5223 5224 case 16: 5225 { 5226 setState(691); tfoot(); 5227 } 5228 break; 5229 5230 case 17: 5231 { 5232 setState(692); pTagOpen(); 5233 } 5234 break; 5235 5236 case 18: 5237 { 5238 setState(693); liTagOpen(); 5239 } 5240 break; 5241 5242 case 19: 5243 { 5244 setState(694); trTagOpen(); 5245 } 5246 break; 5247 5248 case 20: 5249 { 5250 setState(695); tdTagOpen(); 5251 } 5252 break; 5253 5254 case 21: 5255 { 5256 setState(696); thTagOpen(); 5257 } 5258 break; 5259 5260 case 22: 5261 { 5262 setState(697); colgroupTagOpen(); 5263 } 5264 break; 5265 5266 case 23: 5267 { 5268 setState(698); ddTagOpen(); 5269 } 5270 break; 5271 5272 case 24: 5273 { 5274 setState(699); dtTagOpen(); 5275 } 5276 break; 5277 5278 case 25: 5279 { 5280 setState(700); headTagOpen(); 5281 } 5282 break; 5283 5284 case 26: 5285 { 5286 setState(701); htmlTagOpen(); 5287 } 5288 break; 5289 5290 case 27: 5291 { 5292 setState(702); optionTagOpen(); 5293 } 5294 break; 5295 5296 case 28: 5297 { 5298 setState(703); tbodyTagOpen(); 5299 } 5300 break; 5301 5302 case 29: 5303 { 5304 setState(704); theadTagOpen(); 5305 } 5306 break; 5307 5308 case 30: 5309 { 5310 setState(705); tfootTagOpen(); 5311 } 5312 break; 5313 5314 case 31: 5315 { 5316 { 5317 setState(706); 5318 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5319 setState(707); match(LEADING_ASTERISK); 5320 } 5321 } 5322 break; 5323 5324 case 32: 5325 { 5326 setState(708); htmlComment(); 5327 } 5328 break; 5329 5330 case 33: 5331 { 5332 setState(709); match(CDATA); 5333 } 5334 break; 5335 5336 case 34: 5337 { 5338 setState(710); match(NEWLINE); 5339 } 5340 break; 5341 5342 case 35: 5343 { 5344 setState(711); text(); 5345 } 5346 break; 5347 5348 case 36: 5349 { 5350 setState(712); javadocInlineTag(); 5351 } 5352 break; 5353 } 5354 } 5355 } 5356 setState(717); 5357 _errHandler.sync(this); 5358 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5359 } 5360 setState(718); bodyTagClose(); 5361 } 5362 } 5363 catch (RecognitionException re) { 5364 _localctx.exception = re; 5365 _errHandler.reportError(this, re); 5366 _errHandler.recover(this, re); 5367 } 5368 finally { 5369 exitRule(); 5370 } 5371 return _localctx; 5372 } 5373 5374 public static class ColgroupTagOpenContext extends ParserRuleContext { 5375 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5376 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5377 public TerminalNode NEWLINE(int i) { 5378 return getToken(JavadocParser.NEWLINE, i); 5379 } 5380 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5381 public List<AttributeContext> attribute() { 5382 return getRuleContexts(AttributeContext.class); 5383 } 5384 public AttributeContext attribute(int i) { 5385 return getRuleContext(AttributeContext.class,i); 5386 } 5387 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5388 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5389 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5390 public TerminalNode LEADING_ASTERISK(int i) { 5391 return getToken(JavadocParser.LEADING_ASTERISK, i); 5392 } 5393 public TerminalNode WS(int i) { 5394 return getToken(JavadocParser.WS, i); 5395 } 5396 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5397 super(parent, invokingState); 5398 } 5399 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5400 @Override 5401 public void enterRule(ParseTreeListener listener) { 5402 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5403 } 5404 @Override 5405 public void exitRule(ParseTreeListener listener) { 5406 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5407 } 5408 @Override 5409 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5410 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5411 else return visitor.visitChildren(this); 5412 } 5413 } 5414 5415 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5416 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5417 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5418 int _la; 5419 try { 5420 enterOuterAlt(_localctx, 1); 5421 { 5422 setState(720); match(OPEN); 5423 setState(721); match(COLGROUP_HTML_TAG_NAME); 5424 setState(728); 5425 _errHandler.sync(this); 5426 _la = _input.LA(1); 5427 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5428 { 5429 setState(726); 5430 switch (_input.LA(1)) { 5431 case HTML_TAG_NAME: 5432 { 5433 setState(722); attribute(); 5434 } 5435 break; 5436 case NEWLINE: 5437 { 5438 setState(723); match(NEWLINE); 5439 } 5440 break; 5441 case LEADING_ASTERISK: 5442 { 5443 setState(724); match(LEADING_ASTERISK); 5444 } 5445 break; 5446 case WS: 5447 { 5448 setState(725); match(WS); 5449 } 5450 break; 5451 default: 5452 throw new NoViableAltException(this); 5453 } 5454 } 5455 setState(730); 5456 _errHandler.sync(this); 5457 _la = _input.LA(1); 5458 } 5459 setState(731); match(CLOSE); 5460 } 5461 } 5462 catch (RecognitionException re) { 5463 _localctx.exception = re; 5464 _errHandler.reportError(this, re); 5465 _errHandler.recover(this, re); 5466 } 5467 finally { 5468 exitRule(); 5469 } 5470 return _localctx; 5471 } 5472 5473 public static class ColgroupTagCloseContext extends ParserRuleContext { 5474 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5475 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5476 public TerminalNode NEWLINE(int i) { 5477 return getToken(JavadocParser.NEWLINE, i); 5478 } 5479 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5480 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5481 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5482 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5483 public TerminalNode LEADING_ASTERISK(int i) { 5484 return getToken(JavadocParser.LEADING_ASTERISK, i); 5485 } 5486 public TerminalNode WS(int i) { 5487 return getToken(JavadocParser.WS, i); 5488 } 5489 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5490 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5491 super(parent, invokingState); 5492 } 5493 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5494 @Override 5495 public void enterRule(ParseTreeListener listener) { 5496 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5497 } 5498 @Override 5499 public void exitRule(ParseTreeListener listener) { 5500 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5501 } 5502 @Override 5503 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5504 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5505 else return visitor.visitChildren(this); 5506 } 5507 } 5508 5509 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5510 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5511 enterRule(_localctx, 50, RULE_colgroupTagClose); 5512 int _la; 5513 try { 5514 enterOuterAlt(_localctx, 1); 5515 { 5516 setState(733); match(OPEN); 5517 setState(734); match(SLASH); 5518 setState(735); match(COLGROUP_HTML_TAG_NAME); 5519 setState(739); 5520 _errHandler.sync(this); 5521 _la = _input.LA(1); 5522 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5523 { 5524 { 5525 setState(736); 5526 _la = _input.LA(1); 5527 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5528 _errHandler.recoverInline(this); 5529 } 5530 consume(); 5531 } 5532 } 5533 setState(741); 5534 _errHandler.sync(this); 5535 _la = _input.LA(1); 5536 } 5537 setState(742); match(CLOSE); 5538 } 5539 } 5540 catch (RecognitionException re) { 5541 _localctx.exception = re; 5542 _errHandler.reportError(this, re); 5543 _errHandler.recover(this, re); 5544 } 5545 finally { 5546 exitRule(); 5547 } 5548 return _localctx; 5549 } 5550 5551 public static class ColgroupContext extends ParserRuleContext { 5552 public ColgroupTagOpenContext colgroupTagOpen() { 5553 return getRuleContext(ColgroupTagOpenContext.class,0); 5554 } 5555 public TbodyContext tbody(int i) { 5556 return getRuleContext(TbodyContext.class,i); 5557 } 5558 public TerminalNode CDATA(int i) { 5559 return getToken(JavadocParser.CDATA, i); 5560 } 5561 public TfootTagOpenContext tfootTagOpen(int i) { 5562 return getRuleContext(TfootTagOpenContext.class,i); 5563 } 5564 public List<DtTagOpenContext> dtTagOpen() { 5565 return getRuleContexts(DtTagOpenContext.class); 5566 } 5567 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5568 public HeadContext head(int i) { 5569 return getRuleContext(HeadContext.class,i); 5570 } 5571 public List<TrContext> tr() { 5572 return getRuleContexts(TrContext.class); 5573 } 5574 public List<LiContext> li() { 5575 return getRuleContexts(LiContext.class); 5576 } 5577 public ThTagOpenContext thTagOpen(int i) { 5578 return getRuleContext(ThTagOpenContext.class,i); 5579 } 5580 public List<DdTagOpenContext> ddTagOpen() { 5581 return getRuleContexts(DdTagOpenContext.class); 5582 } 5583 public TdTagOpenContext tdTagOpen(int i) { 5584 return getRuleContext(TdTagOpenContext.class,i); 5585 } 5586 public List<ThTagOpenContext> thTagOpen() { 5587 return getRuleContexts(ThTagOpenContext.class); 5588 } 5589 public List<HeadTagOpenContext> headTagOpen() { 5590 return getRuleContexts(HeadTagOpenContext.class); 5591 } 5592 public List<HtmlTagOpenContext> htmlTagOpen() { 5593 return getRuleContexts(HtmlTagOpenContext.class); 5594 } 5595 public List<TbodyTagOpenContext> tbodyTagOpen() { 5596 return getRuleContexts(TbodyTagOpenContext.class); 5597 } 5598 public List<TheadContext> thead() { 5599 return getRuleContexts(TheadContext.class); 5600 } 5601 public LiContext li(int i) { 5602 return getRuleContext(LiContext.class,i); 5603 } 5604 public List<TfootTagOpenContext> tfootTagOpen() { 5605 return getRuleContexts(TfootTagOpenContext.class); 5606 } 5607 public List<TfootContext> tfoot() { 5608 return getRuleContexts(TfootContext.class); 5609 } 5610 public List<JavadocInlineTagContext> javadocInlineTag() { 5611 return getRuleContexts(JavadocInlineTagContext.class); 5612 } 5613 public List<HtmlCommentContext> htmlComment() { 5614 return getRuleContexts(HtmlCommentContext.class); 5615 } 5616 public OptionContext option(int i) { 5617 return getRuleContext(OptionContext.class,i); 5618 } 5619 public TrContext tr(int i) { 5620 return getRuleContext(TrContext.class,i); 5621 } 5622 public List<DtContext> dt() { 5623 return getRuleContexts(DtContext.class); 5624 } 5625 public HtmlCommentContext htmlComment(int i) { 5626 return getRuleContext(HtmlCommentContext.class,i); 5627 } 5628 public List<TdContext> td() { 5629 return getRuleContexts(TdContext.class); 5630 } 5631 public List<BodyTagOpenContext> bodyTagOpen() { 5632 return getRuleContexts(BodyTagOpenContext.class); 5633 } 5634 public DtTagOpenContext dtTagOpen(int i) { 5635 return getRuleContext(DtTagOpenContext.class,i); 5636 } 5637 public HtmlContext html(int i) { 5638 return getRuleContext(HtmlContext.class,i); 5639 } 5640 public BodyTagOpenContext bodyTagOpen(int i) { 5641 return getRuleContext(BodyTagOpenContext.class,i); 5642 } 5643 public DdTagOpenContext ddTagOpen(int i) { 5644 return getRuleContext(DdTagOpenContext.class,i); 5645 } 5646 public List<HtmlTagContext> htmlTag() { 5647 return getRuleContexts(HtmlTagContext.class); 5648 } 5649 public ParagraphContext paragraph(int i) { 5650 return getRuleContext(ParagraphContext.class,i); 5651 } 5652 public List<TdTagOpenContext> tdTagOpen() { 5653 return getRuleContexts(TdTagOpenContext.class); 5654 } 5655 public OptionTagOpenContext optionTagOpen(int i) { 5656 return getRuleContext(OptionTagOpenContext.class,i); 5657 } 5658 public LiTagOpenContext liTagOpen(int i) { 5659 return getRuleContext(LiTagOpenContext.class,i); 5660 } 5661 public TdContext td(int i) { 5662 return getRuleContext(TdContext.class,i); 5663 } 5664 public List<ParagraphContext> paragraph() { 5665 return getRuleContexts(ParagraphContext.class); 5666 } 5667 public HtmlTagContext htmlTag(int i) { 5668 return getRuleContext(HtmlTagContext.class,i); 5669 } 5670 public List<SingletonTagContext> singletonTag() { 5671 return getRuleContexts(SingletonTagContext.class); 5672 } 5673 public HeadTagOpenContext headTagOpen(int i) { 5674 return getRuleContext(HeadTagOpenContext.class,i); 5675 } 5676 public TrTagOpenContext trTagOpen(int i) { 5677 return getRuleContext(TrTagOpenContext.class,i); 5678 } 5679 public List<HtmlContext> html() { 5680 return getRuleContexts(HtmlContext.class); 5681 } 5682 public JavadocInlineTagContext javadocInlineTag(int i) { 5683 return getRuleContext(JavadocInlineTagContext.class,i); 5684 } 5685 public List<ThContext> th() { 5686 return getRuleContexts(ThContext.class); 5687 } 5688 public DtContext dt(int i) { 5689 return getRuleContext(DtContext.class,i); 5690 } 5691 public PTagOpenContext pTagOpen(int i) { 5692 return getRuleContext(PTagOpenContext.class,i); 5693 } 5694 public TerminalNode LEADING_ASTERISK(int i) { 5695 return getToken(JavadocParser.LEADING_ASTERISK, i); 5696 } 5697 public List<TrTagOpenContext> trTagOpen() { 5698 return getRuleContexts(TrTagOpenContext.class); 5699 } 5700 public List<TbodyContext> tbody() { 5701 return getRuleContexts(TbodyContext.class); 5702 } 5703 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5704 public List<TheadTagOpenContext> theadTagOpen() { 5705 return getRuleContexts(TheadTagOpenContext.class); 5706 } 5707 public List<HeadContext> head() { 5708 return getRuleContexts(HeadContext.class); 5709 } 5710 public TerminalNode NEWLINE(int i) { 5711 return getToken(JavadocParser.NEWLINE, i); 5712 } 5713 public TextContext text(int i) { 5714 return getRuleContext(TextContext.class,i); 5715 } 5716 public List<BodyContext> body() { 5717 return getRuleContexts(BodyContext.class); 5718 } 5719 public List<OptionTagOpenContext> optionTagOpen() { 5720 return getRuleContexts(OptionTagOpenContext.class); 5721 } 5722 public List<TextContext> text() { 5723 return getRuleContexts(TextContext.class); 5724 } 5725 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5726 public TbodyTagOpenContext tbodyTagOpen(int i) { 5727 return getRuleContext(TbodyTagOpenContext.class,i); 5728 } 5729 public List<DdContext> dd() { 5730 return getRuleContexts(DdContext.class); 5731 } 5732 public TheadTagOpenContext theadTagOpen(int i) { 5733 return getRuleContext(TheadTagOpenContext.class,i); 5734 } 5735 public ColgroupTagCloseContext colgroupTagClose() { 5736 return getRuleContext(ColgroupTagCloseContext.class,0); 5737 } 5738 public List<LiTagOpenContext> liTagOpen() { 5739 return getRuleContexts(LiTagOpenContext.class); 5740 } 5741 public DdContext dd(int i) { 5742 return getRuleContext(DdContext.class,i); 5743 } 5744 public List<OptionContext> option() { 5745 return getRuleContexts(OptionContext.class); 5746 } 5747 public TheadContext thead(int i) { 5748 return getRuleContext(TheadContext.class,i); 5749 } 5750 public BodyContext body(int i) { 5751 return getRuleContext(BodyContext.class,i); 5752 } 5753 public ThContext th(int i) { 5754 return getRuleContext(ThContext.class,i); 5755 } 5756 public List<PTagOpenContext> pTagOpen() { 5757 return getRuleContexts(PTagOpenContext.class); 5758 } 5759 public HtmlTagOpenContext htmlTagOpen(int i) { 5760 return getRuleContext(HtmlTagOpenContext.class,i); 5761 } 5762 public SingletonTagContext singletonTag(int i) { 5763 return getRuleContext(SingletonTagContext.class,i); 5764 } 5765 public TfootContext tfoot(int i) { 5766 return getRuleContext(TfootContext.class,i); 5767 } 5768 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5769 super(parent, invokingState); 5770 } 5771 @Override public int getRuleIndex() { return RULE_colgroup; } 5772 @Override 5773 public void enterRule(ParseTreeListener listener) { 5774 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 5775 } 5776 @Override 5777 public void exitRule(ParseTreeListener listener) { 5778 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 5779 } 5780 @Override 5781 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5782 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 5783 else return visitor.visitChildren(this); 5784 } 5785 } 5786 5787 public final ColgroupContext colgroup() throws RecognitionException { 5788 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 5789 enterRule(_localctx, 52, RULE_colgroup); 5790 try { 5791 int _alt; 5792 enterOuterAlt(_localctx, 1); 5793 { 5794 setState(744); colgroupTagOpen(); 5795 setState(784); 5796 _errHandler.sync(this); 5797 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 5798 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5799 if ( _alt==1 ) { 5800 { 5801 setState(782); 5802 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 5803 case 1: 5804 { 5805 setState(745); htmlTag(); 5806 } 5807 break; 5808 5809 case 2: 5810 { 5811 setState(746); singletonTag(); 5812 } 5813 break; 5814 5815 case 3: 5816 { 5817 setState(747); paragraph(); 5818 } 5819 break; 5820 5821 case 4: 5822 { 5823 setState(748); li(); 5824 } 5825 break; 5826 5827 case 5: 5828 { 5829 setState(749); tr(); 5830 } 5831 break; 5832 5833 case 6: 5834 { 5835 setState(750); td(); 5836 } 5837 break; 5838 5839 case 7: 5840 { 5841 setState(751); th(); 5842 } 5843 break; 5844 5845 case 8: 5846 { 5847 setState(752); body(); 5848 } 5849 break; 5850 5851 case 9: 5852 { 5853 setState(753); dd(); 5854 } 5855 break; 5856 5857 case 10: 5858 { 5859 setState(754); dt(); 5860 } 5861 break; 5862 5863 case 11: 5864 { 5865 setState(755); head(); 5866 } 5867 break; 5868 5869 case 12: 5870 { 5871 setState(756); html(); 5872 } 5873 break; 5874 5875 case 13: 5876 { 5877 setState(757); option(); 5878 } 5879 break; 5880 5881 case 14: 5882 { 5883 setState(758); tbody(); 5884 } 5885 break; 5886 5887 case 15: 5888 { 5889 setState(759); thead(); 5890 } 5891 break; 5892 5893 case 16: 5894 { 5895 setState(760); tfoot(); 5896 } 5897 break; 5898 5899 case 17: 5900 { 5901 setState(761); pTagOpen(); 5902 } 5903 break; 5904 5905 case 18: 5906 { 5907 setState(762); liTagOpen(); 5908 } 5909 break; 5910 5911 case 19: 5912 { 5913 setState(763); trTagOpen(); 5914 } 5915 break; 5916 5917 case 20: 5918 { 5919 setState(764); tdTagOpen(); 5920 } 5921 break; 5922 5923 case 21: 5924 { 5925 setState(765); thTagOpen(); 5926 } 5927 break; 5928 5929 case 22: 5930 { 5931 setState(766); bodyTagOpen(); 5932 } 5933 break; 5934 5935 case 23: 5936 { 5937 setState(767); ddTagOpen(); 5938 } 5939 break; 5940 5941 case 24: 5942 { 5943 setState(768); dtTagOpen(); 5944 } 5945 break; 5946 5947 case 25: 5948 { 5949 setState(769); headTagOpen(); 5950 } 5951 break; 5952 5953 case 26: 5954 { 5955 setState(770); htmlTagOpen(); 5956 } 5957 break; 5958 5959 case 27: 5960 { 5961 setState(771); optionTagOpen(); 5962 } 5963 break; 5964 5965 case 28: 5966 { 5967 setState(772); tbodyTagOpen(); 5968 } 5969 break; 5970 5971 case 29: 5972 { 5973 setState(773); theadTagOpen(); 5974 } 5975 break; 5976 5977 case 30: 5978 { 5979 setState(774); tfootTagOpen(); 5980 } 5981 break; 5982 5983 case 31: 5984 { 5985 { 5986 setState(775); 5987 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5988 setState(776); match(LEADING_ASTERISK); 5989 } 5990 } 5991 break; 5992 5993 case 32: 5994 { 5995 setState(777); htmlComment(); 5996 } 5997 break; 5998 5999 case 33: 6000 { 6001 setState(778); match(CDATA); 6002 } 6003 break; 6004 6005 case 34: 6006 { 6007 setState(779); match(NEWLINE); 6008 } 6009 break; 6010 6011 case 35: 6012 { 6013 setState(780); text(); 6014 } 6015 break; 6016 6017 case 36: 6018 { 6019 setState(781); javadocInlineTag(); 6020 } 6021 break; 6022 } 6023 } 6024 } 6025 setState(786); 6026 _errHandler.sync(this); 6027 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6028 } 6029 setState(787); colgroupTagClose(); 6030 } 6031 } 6032 catch (RecognitionException re) { 6033 _localctx.exception = re; 6034 _errHandler.reportError(this, re); 6035 _errHandler.recover(this, re); 6036 } 6037 finally { 6038 exitRule(); 6039 } 6040 return _localctx; 6041 } 6042 6043 public static class DdTagOpenContext extends ParserRuleContext { 6044 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6045 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6046 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6047 public TerminalNode NEWLINE(int i) { 6048 return getToken(JavadocParser.NEWLINE, i); 6049 } 6050 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6051 public List<AttributeContext> attribute() { 6052 return getRuleContexts(AttributeContext.class); 6053 } 6054 public AttributeContext attribute(int i) { 6055 return getRuleContext(AttributeContext.class,i); 6056 } 6057 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6058 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6059 public TerminalNode LEADING_ASTERISK(int i) { 6060 return getToken(JavadocParser.LEADING_ASTERISK, i); 6061 } 6062 public TerminalNode WS(int i) { 6063 return getToken(JavadocParser.WS, i); 6064 } 6065 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6066 super(parent, invokingState); 6067 } 6068 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6069 @Override 6070 public void enterRule(ParseTreeListener listener) { 6071 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6072 } 6073 @Override 6074 public void exitRule(ParseTreeListener listener) { 6075 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6076 } 6077 @Override 6078 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6079 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6080 else return visitor.visitChildren(this); 6081 } 6082 } 6083 6084 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6085 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6086 enterRule(_localctx, 54, RULE_ddTagOpen); 6087 int _la; 6088 try { 6089 enterOuterAlt(_localctx, 1); 6090 { 6091 setState(789); match(OPEN); 6092 setState(790); match(DD_HTML_TAG_NAME); 6093 setState(797); 6094 _errHandler.sync(this); 6095 _la = _input.LA(1); 6096 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6097 { 6098 setState(795); 6099 switch (_input.LA(1)) { 6100 case HTML_TAG_NAME: 6101 { 6102 setState(791); attribute(); 6103 } 6104 break; 6105 case NEWLINE: 6106 { 6107 setState(792); match(NEWLINE); 6108 } 6109 break; 6110 case LEADING_ASTERISK: 6111 { 6112 setState(793); match(LEADING_ASTERISK); 6113 } 6114 break; 6115 case WS: 6116 { 6117 setState(794); match(WS); 6118 } 6119 break; 6120 default: 6121 throw new NoViableAltException(this); 6122 } 6123 } 6124 setState(799); 6125 _errHandler.sync(this); 6126 _la = _input.LA(1); 6127 } 6128 setState(800); match(CLOSE); 6129 } 6130 } 6131 catch (RecognitionException re) { 6132 _localctx.exception = re; 6133 _errHandler.reportError(this, re); 6134 _errHandler.recover(this, re); 6135 } 6136 finally { 6137 exitRule(); 6138 } 6139 return _localctx; 6140 } 6141 6142 public static class DdTagCloseContext extends ParserRuleContext { 6143 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6144 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6145 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6146 public TerminalNode NEWLINE(int i) { 6147 return getToken(JavadocParser.NEWLINE, i); 6148 } 6149 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6150 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6151 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6152 public TerminalNode LEADING_ASTERISK(int i) { 6153 return getToken(JavadocParser.LEADING_ASTERISK, i); 6154 } 6155 public TerminalNode WS(int i) { 6156 return getToken(JavadocParser.WS, i); 6157 } 6158 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6159 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6160 super(parent, invokingState); 6161 } 6162 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6163 @Override 6164 public void enterRule(ParseTreeListener listener) { 6165 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6166 } 6167 @Override 6168 public void exitRule(ParseTreeListener listener) { 6169 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6170 } 6171 @Override 6172 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6173 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6174 else return visitor.visitChildren(this); 6175 } 6176 } 6177 6178 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6179 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6180 enterRule(_localctx, 56, RULE_ddTagClose); 6181 int _la; 6182 try { 6183 enterOuterAlt(_localctx, 1); 6184 { 6185 setState(802); match(OPEN); 6186 setState(803); match(SLASH); 6187 setState(804); match(DD_HTML_TAG_NAME); 6188 setState(808); 6189 _errHandler.sync(this); 6190 _la = _input.LA(1); 6191 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6192 { 6193 { 6194 setState(805); 6195 _la = _input.LA(1); 6196 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6197 _errHandler.recoverInline(this); 6198 } 6199 consume(); 6200 } 6201 } 6202 setState(810); 6203 _errHandler.sync(this); 6204 _la = _input.LA(1); 6205 } 6206 setState(811); match(CLOSE); 6207 } 6208 } 6209 catch (RecognitionException re) { 6210 _localctx.exception = re; 6211 _errHandler.reportError(this, re); 6212 _errHandler.recover(this, re); 6213 } 6214 finally { 6215 exitRule(); 6216 } 6217 return _localctx; 6218 } 6219 6220 public static class DdContext extends ParserRuleContext { 6221 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6222 return getRuleContexts(ColgroupTagOpenContext.class); 6223 } 6224 public TbodyContext tbody(int i) { 6225 return getRuleContext(TbodyContext.class,i); 6226 } 6227 public TerminalNode CDATA(int i) { 6228 return getToken(JavadocParser.CDATA, i); 6229 } 6230 public TfootTagOpenContext tfootTagOpen(int i) { 6231 return getRuleContext(TfootTagOpenContext.class,i); 6232 } 6233 public DdTagCloseContext ddTagClose() { 6234 return getRuleContext(DdTagCloseContext.class,0); 6235 } 6236 public List<DtTagOpenContext> dtTagOpen() { 6237 return getRuleContexts(DtTagOpenContext.class); 6238 } 6239 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6240 public HeadContext head(int i) { 6241 return getRuleContext(HeadContext.class,i); 6242 } 6243 public List<ColgroupContext> colgroup() { 6244 return getRuleContexts(ColgroupContext.class); 6245 } 6246 public List<TrContext> tr() { 6247 return getRuleContexts(TrContext.class); 6248 } 6249 public List<LiContext> li() { 6250 return getRuleContexts(LiContext.class); 6251 } 6252 public ThTagOpenContext thTagOpen(int i) { 6253 return getRuleContext(ThTagOpenContext.class,i); 6254 } 6255 public DdTagOpenContext ddTagOpen() { 6256 return getRuleContext(DdTagOpenContext.class,0); 6257 } 6258 public ColgroupContext colgroup(int i) { 6259 return getRuleContext(ColgroupContext.class,i); 6260 } 6261 public TdTagOpenContext tdTagOpen(int i) { 6262 return getRuleContext(TdTagOpenContext.class,i); 6263 } 6264 public List<ThTagOpenContext> thTagOpen() { 6265 return getRuleContexts(ThTagOpenContext.class); 6266 } 6267 public List<HeadTagOpenContext> headTagOpen() { 6268 return getRuleContexts(HeadTagOpenContext.class); 6269 } 6270 public List<HtmlTagOpenContext> htmlTagOpen() { 6271 return getRuleContexts(HtmlTagOpenContext.class); 6272 } 6273 public List<TbodyTagOpenContext> tbodyTagOpen() { 6274 return getRuleContexts(TbodyTagOpenContext.class); 6275 } 6276 public List<TheadContext> thead() { 6277 return getRuleContexts(TheadContext.class); 6278 } 6279 public LiContext li(int i) { 6280 return getRuleContext(LiContext.class,i); 6281 } 6282 public List<TfootTagOpenContext> tfootTagOpen() { 6283 return getRuleContexts(TfootTagOpenContext.class); 6284 } 6285 public List<TfootContext> tfoot() { 6286 return getRuleContexts(TfootContext.class); 6287 } 6288 public List<JavadocInlineTagContext> javadocInlineTag() { 6289 return getRuleContexts(JavadocInlineTagContext.class); 6290 } 6291 public List<HtmlCommentContext> htmlComment() { 6292 return getRuleContexts(HtmlCommentContext.class); 6293 } 6294 public OptionContext option(int i) { 6295 return getRuleContext(OptionContext.class,i); 6296 } 6297 public TrContext tr(int i) { 6298 return getRuleContext(TrContext.class,i); 6299 } 6300 public List<DtContext> dt() { 6301 return getRuleContexts(DtContext.class); 6302 } 6303 public HtmlCommentContext htmlComment(int i) { 6304 return getRuleContext(HtmlCommentContext.class,i); 6305 } 6306 public List<TdContext> td() { 6307 return getRuleContexts(TdContext.class); 6308 } 6309 public List<BodyTagOpenContext> bodyTagOpen() { 6310 return getRuleContexts(BodyTagOpenContext.class); 6311 } 6312 public DtTagOpenContext dtTagOpen(int i) { 6313 return getRuleContext(DtTagOpenContext.class,i); 6314 } 6315 public HtmlContext html(int i) { 6316 return getRuleContext(HtmlContext.class,i); 6317 } 6318 public BodyTagOpenContext bodyTagOpen(int i) { 6319 return getRuleContext(BodyTagOpenContext.class,i); 6320 } 6321 public List<HtmlTagContext> htmlTag() { 6322 return getRuleContexts(HtmlTagContext.class); 6323 } 6324 public ParagraphContext paragraph(int i) { 6325 return getRuleContext(ParagraphContext.class,i); 6326 } 6327 public List<TdTagOpenContext> tdTagOpen() { 6328 return getRuleContexts(TdTagOpenContext.class); 6329 } 6330 public OptionTagOpenContext optionTagOpen(int i) { 6331 return getRuleContext(OptionTagOpenContext.class,i); 6332 } 6333 public LiTagOpenContext liTagOpen(int i) { 6334 return getRuleContext(LiTagOpenContext.class,i); 6335 } 6336 public TdContext td(int i) { 6337 return getRuleContext(TdContext.class,i); 6338 } 6339 public List<ParagraphContext> paragraph() { 6340 return getRuleContexts(ParagraphContext.class); 6341 } 6342 public HtmlTagContext htmlTag(int i) { 6343 return getRuleContext(HtmlTagContext.class,i); 6344 } 6345 public List<SingletonTagContext> singletonTag() { 6346 return getRuleContexts(SingletonTagContext.class); 6347 } 6348 public HeadTagOpenContext headTagOpen(int i) { 6349 return getRuleContext(HeadTagOpenContext.class,i); 6350 } 6351 public TrTagOpenContext trTagOpen(int i) { 6352 return getRuleContext(TrTagOpenContext.class,i); 6353 } 6354 public List<HtmlContext> html() { 6355 return getRuleContexts(HtmlContext.class); 6356 } 6357 public JavadocInlineTagContext javadocInlineTag(int i) { 6358 return getRuleContext(JavadocInlineTagContext.class,i); 6359 } 6360 public List<ThContext> th() { 6361 return getRuleContexts(ThContext.class); 6362 } 6363 public DtContext dt(int i) { 6364 return getRuleContext(DtContext.class,i); 6365 } 6366 public PTagOpenContext pTagOpen(int i) { 6367 return getRuleContext(PTagOpenContext.class,i); 6368 } 6369 public TerminalNode LEADING_ASTERISK(int i) { 6370 return getToken(JavadocParser.LEADING_ASTERISK, i); 6371 } 6372 public List<TrTagOpenContext> trTagOpen() { 6373 return getRuleContexts(TrTagOpenContext.class); 6374 } 6375 public List<TbodyContext> tbody() { 6376 return getRuleContexts(TbodyContext.class); 6377 } 6378 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6379 public List<TheadTagOpenContext> theadTagOpen() { 6380 return getRuleContexts(TheadTagOpenContext.class); 6381 } 6382 public List<HeadContext> head() { 6383 return getRuleContexts(HeadContext.class); 6384 } 6385 public TerminalNode NEWLINE(int i) { 6386 return getToken(JavadocParser.NEWLINE, i); 6387 } 6388 public TextContext text(int i) { 6389 return getRuleContext(TextContext.class,i); 6390 } 6391 public List<BodyContext> body() { 6392 return getRuleContexts(BodyContext.class); 6393 } 6394 public List<OptionTagOpenContext> optionTagOpen() { 6395 return getRuleContexts(OptionTagOpenContext.class); 6396 } 6397 public List<TextContext> text() { 6398 return getRuleContexts(TextContext.class); 6399 } 6400 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6401 public TbodyTagOpenContext tbodyTagOpen(int i) { 6402 return getRuleContext(TbodyTagOpenContext.class,i); 6403 } 6404 public TheadTagOpenContext theadTagOpen(int i) { 6405 return getRuleContext(TheadTagOpenContext.class,i); 6406 } 6407 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6408 return getRuleContext(ColgroupTagOpenContext.class,i); 6409 } 6410 public List<LiTagOpenContext> liTagOpen() { 6411 return getRuleContexts(LiTagOpenContext.class); 6412 } 6413 public List<OptionContext> option() { 6414 return getRuleContexts(OptionContext.class); 6415 } 6416 public TheadContext thead(int i) { 6417 return getRuleContext(TheadContext.class,i); 6418 } 6419 public BodyContext body(int i) { 6420 return getRuleContext(BodyContext.class,i); 6421 } 6422 public ThContext th(int i) { 6423 return getRuleContext(ThContext.class,i); 6424 } 6425 public List<PTagOpenContext> pTagOpen() { 6426 return getRuleContexts(PTagOpenContext.class); 6427 } 6428 public HtmlTagOpenContext htmlTagOpen(int i) { 6429 return getRuleContext(HtmlTagOpenContext.class,i); 6430 } 6431 public SingletonTagContext singletonTag(int i) { 6432 return getRuleContext(SingletonTagContext.class,i); 6433 } 6434 public TfootContext tfoot(int i) { 6435 return getRuleContext(TfootContext.class,i); 6436 } 6437 public DdContext(ParserRuleContext parent, int invokingState) { 6438 super(parent, invokingState); 6439 } 6440 @Override public int getRuleIndex() { return RULE_dd; } 6441 @Override 6442 public void enterRule(ParseTreeListener listener) { 6443 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6444 } 6445 @Override 6446 public void exitRule(ParseTreeListener listener) { 6447 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6448 } 6449 @Override 6450 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6451 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6452 else return visitor.visitChildren(this); 6453 } 6454 } 6455 6456 public final DdContext dd() throws RecognitionException { 6457 DdContext _localctx = new DdContext(_ctx, getState()); 6458 enterRule(_localctx, 58, RULE_dd); 6459 try { 6460 int _alt; 6461 enterOuterAlt(_localctx, 1); 6462 { 6463 setState(813); ddTagOpen(); 6464 setState(853); 6465 _errHandler.sync(this); 6466 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6467 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6468 if ( _alt==1 ) { 6469 { 6470 setState(851); 6471 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6472 case 1: 6473 { 6474 setState(814); htmlTag(); 6475 } 6476 break; 6477 6478 case 2: 6479 { 6480 setState(815); singletonTag(); 6481 } 6482 break; 6483 6484 case 3: 6485 { 6486 setState(816); paragraph(); 6487 } 6488 break; 6489 6490 case 4: 6491 { 6492 setState(817); li(); 6493 } 6494 break; 6495 6496 case 5: 6497 { 6498 setState(818); tr(); 6499 } 6500 break; 6501 6502 case 6: 6503 { 6504 setState(819); td(); 6505 } 6506 break; 6507 6508 case 7: 6509 { 6510 setState(820); th(); 6511 } 6512 break; 6513 6514 case 8: 6515 { 6516 setState(821); body(); 6517 } 6518 break; 6519 6520 case 9: 6521 { 6522 setState(822); colgroup(); 6523 } 6524 break; 6525 6526 case 10: 6527 { 6528 setState(823); dt(); 6529 } 6530 break; 6531 6532 case 11: 6533 { 6534 setState(824); head(); 6535 } 6536 break; 6537 6538 case 12: 6539 { 6540 setState(825); html(); 6541 } 6542 break; 6543 6544 case 13: 6545 { 6546 setState(826); option(); 6547 } 6548 break; 6549 6550 case 14: 6551 { 6552 setState(827); tbody(); 6553 } 6554 break; 6555 6556 case 15: 6557 { 6558 setState(828); thead(); 6559 } 6560 break; 6561 6562 case 16: 6563 { 6564 setState(829); tfoot(); 6565 } 6566 break; 6567 6568 case 17: 6569 { 6570 setState(830); pTagOpen(); 6571 } 6572 break; 6573 6574 case 18: 6575 { 6576 setState(831); liTagOpen(); 6577 } 6578 break; 6579 6580 case 19: 6581 { 6582 setState(832); trTagOpen(); 6583 } 6584 break; 6585 6586 case 20: 6587 { 6588 setState(833); tdTagOpen(); 6589 } 6590 break; 6591 6592 case 21: 6593 { 6594 setState(834); thTagOpen(); 6595 } 6596 break; 6597 6598 case 22: 6599 { 6600 setState(835); bodyTagOpen(); 6601 } 6602 break; 6603 6604 case 23: 6605 { 6606 setState(836); colgroupTagOpen(); 6607 } 6608 break; 6609 6610 case 24: 6611 { 6612 setState(837); dtTagOpen(); 6613 } 6614 break; 6615 6616 case 25: 6617 { 6618 setState(838); headTagOpen(); 6619 } 6620 break; 6621 6622 case 26: 6623 { 6624 setState(839); htmlTagOpen(); 6625 } 6626 break; 6627 6628 case 27: 6629 { 6630 setState(840); optionTagOpen(); 6631 } 6632 break; 6633 6634 case 28: 6635 { 6636 setState(841); tbodyTagOpen(); 6637 } 6638 break; 6639 6640 case 29: 6641 { 6642 setState(842); theadTagOpen(); 6643 } 6644 break; 6645 6646 case 30: 6647 { 6648 setState(843); tfootTagOpen(); 6649 } 6650 break; 6651 6652 case 31: 6653 { 6654 { 6655 setState(844); 6656 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6657 setState(845); match(LEADING_ASTERISK); 6658 } 6659 } 6660 break; 6661 6662 case 32: 6663 { 6664 setState(846); htmlComment(); 6665 } 6666 break; 6667 6668 case 33: 6669 { 6670 setState(847); match(CDATA); 6671 } 6672 break; 6673 6674 case 34: 6675 { 6676 setState(848); match(NEWLINE); 6677 } 6678 break; 6679 6680 case 35: 6681 { 6682 setState(849); text(); 6683 } 6684 break; 6685 6686 case 36: 6687 { 6688 setState(850); javadocInlineTag(); 6689 } 6690 break; 6691 } 6692 } 6693 } 6694 setState(855); 6695 _errHandler.sync(this); 6696 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6697 } 6698 setState(856); ddTagClose(); 6699 } 6700 } 6701 catch (RecognitionException re) { 6702 _localctx.exception = re; 6703 _errHandler.reportError(this, re); 6704 _errHandler.recover(this, re); 6705 } 6706 finally { 6707 exitRule(); 6708 } 6709 return _localctx; 6710 } 6711 6712 public static class DtTagOpenContext extends ParserRuleContext { 6713 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6714 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6715 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6716 public TerminalNode NEWLINE(int i) { 6717 return getToken(JavadocParser.NEWLINE, i); 6718 } 6719 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6720 public List<AttributeContext> attribute() { 6721 return getRuleContexts(AttributeContext.class); 6722 } 6723 public AttributeContext attribute(int i) { 6724 return getRuleContext(AttributeContext.class,i); 6725 } 6726 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6727 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6728 public TerminalNode LEADING_ASTERISK(int i) { 6729 return getToken(JavadocParser.LEADING_ASTERISK, i); 6730 } 6731 public TerminalNode WS(int i) { 6732 return getToken(JavadocParser.WS, i); 6733 } 6734 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6735 super(parent, invokingState); 6736 } 6737 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6738 @Override 6739 public void enterRule(ParseTreeListener listener) { 6740 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 6741 } 6742 @Override 6743 public void exitRule(ParseTreeListener listener) { 6744 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 6745 } 6746 @Override 6747 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6748 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 6749 else return visitor.visitChildren(this); 6750 } 6751 } 6752 6753 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 6754 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 6755 enterRule(_localctx, 60, RULE_dtTagOpen); 6756 int _la; 6757 try { 6758 enterOuterAlt(_localctx, 1); 6759 { 6760 setState(858); match(OPEN); 6761 setState(859); match(DT_HTML_TAG_NAME); 6762 setState(866); 6763 _errHandler.sync(this); 6764 _la = _input.LA(1); 6765 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6766 { 6767 setState(864); 6768 switch (_input.LA(1)) { 6769 case HTML_TAG_NAME: 6770 { 6771 setState(860); attribute(); 6772 } 6773 break; 6774 case NEWLINE: 6775 { 6776 setState(861); match(NEWLINE); 6777 } 6778 break; 6779 case LEADING_ASTERISK: 6780 { 6781 setState(862); match(LEADING_ASTERISK); 6782 } 6783 break; 6784 case WS: 6785 { 6786 setState(863); match(WS); 6787 } 6788 break; 6789 default: 6790 throw new NoViableAltException(this); 6791 } 6792 } 6793 setState(868); 6794 _errHandler.sync(this); 6795 _la = _input.LA(1); 6796 } 6797 setState(869); match(CLOSE); 6798 } 6799 } 6800 catch (RecognitionException re) { 6801 _localctx.exception = re; 6802 _errHandler.reportError(this, re); 6803 _errHandler.recover(this, re); 6804 } 6805 finally { 6806 exitRule(); 6807 } 6808 return _localctx; 6809 } 6810 6811 public static class DtTagCloseContext extends ParserRuleContext { 6812 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6813 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6814 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6815 public TerminalNode NEWLINE(int i) { 6816 return getToken(JavadocParser.NEWLINE, i); 6817 } 6818 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6819 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6820 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6821 public TerminalNode LEADING_ASTERISK(int i) { 6822 return getToken(JavadocParser.LEADING_ASTERISK, i); 6823 } 6824 public TerminalNode WS(int i) { 6825 return getToken(JavadocParser.WS, i); 6826 } 6827 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6828 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 6829 super(parent, invokingState); 6830 } 6831 @Override public int getRuleIndex() { return RULE_dtTagClose; } 6832 @Override 6833 public void enterRule(ParseTreeListener listener) { 6834 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 6835 } 6836 @Override 6837 public void exitRule(ParseTreeListener listener) { 6838 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 6839 } 6840 @Override 6841 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6842 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 6843 else return visitor.visitChildren(this); 6844 } 6845 } 6846 6847 public final DtTagCloseContext dtTagClose() throws RecognitionException { 6848 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 6849 enterRule(_localctx, 62, RULE_dtTagClose); 6850 int _la; 6851 try { 6852 enterOuterAlt(_localctx, 1); 6853 { 6854 setState(871); match(OPEN); 6855 setState(872); match(SLASH); 6856 setState(873); match(DT_HTML_TAG_NAME); 6857 setState(877); 6858 _errHandler.sync(this); 6859 _la = _input.LA(1); 6860 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6861 { 6862 { 6863 setState(874); 6864 _la = _input.LA(1); 6865 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6866 _errHandler.recoverInline(this); 6867 } 6868 consume(); 6869 } 6870 } 6871 setState(879); 6872 _errHandler.sync(this); 6873 _la = _input.LA(1); 6874 } 6875 setState(880); match(CLOSE); 6876 } 6877 } 6878 catch (RecognitionException re) { 6879 _localctx.exception = re; 6880 _errHandler.reportError(this, re); 6881 _errHandler.recover(this, re); 6882 } 6883 finally { 6884 exitRule(); 6885 } 6886 return _localctx; 6887 } 6888 6889 public static class DtContext extends ParserRuleContext { 6890 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6891 return getRuleContexts(ColgroupTagOpenContext.class); 6892 } 6893 public TbodyContext tbody(int i) { 6894 return getRuleContext(TbodyContext.class,i); 6895 } 6896 public TerminalNode CDATA(int i) { 6897 return getToken(JavadocParser.CDATA, i); 6898 } 6899 public TfootTagOpenContext tfootTagOpen(int i) { 6900 return getRuleContext(TfootTagOpenContext.class,i); 6901 } 6902 public DtTagOpenContext dtTagOpen() { 6903 return getRuleContext(DtTagOpenContext.class,0); 6904 } 6905 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6906 public HeadContext head(int i) { 6907 return getRuleContext(HeadContext.class,i); 6908 } 6909 public List<ColgroupContext> colgroup() { 6910 return getRuleContexts(ColgroupContext.class); 6911 } 6912 public List<TrContext> tr() { 6913 return getRuleContexts(TrContext.class); 6914 } 6915 public List<LiContext> li() { 6916 return getRuleContexts(LiContext.class); 6917 } 6918 public ThTagOpenContext thTagOpen(int i) { 6919 return getRuleContext(ThTagOpenContext.class,i); 6920 } 6921 public List<DdTagOpenContext> ddTagOpen() { 6922 return getRuleContexts(DdTagOpenContext.class); 6923 } 6924 public ColgroupContext colgroup(int i) { 6925 return getRuleContext(ColgroupContext.class,i); 6926 } 6927 public TdTagOpenContext tdTagOpen(int i) { 6928 return getRuleContext(TdTagOpenContext.class,i); 6929 } 6930 public List<ThTagOpenContext> thTagOpen() { 6931 return getRuleContexts(ThTagOpenContext.class); 6932 } 6933 public List<HeadTagOpenContext> headTagOpen() { 6934 return getRuleContexts(HeadTagOpenContext.class); 6935 } 6936 public List<HtmlTagOpenContext> htmlTagOpen() { 6937 return getRuleContexts(HtmlTagOpenContext.class); 6938 } 6939 public List<TbodyTagOpenContext> tbodyTagOpen() { 6940 return getRuleContexts(TbodyTagOpenContext.class); 6941 } 6942 public List<TheadContext> thead() { 6943 return getRuleContexts(TheadContext.class); 6944 } 6945 public LiContext li(int i) { 6946 return getRuleContext(LiContext.class,i); 6947 } 6948 public List<TfootTagOpenContext> tfootTagOpen() { 6949 return getRuleContexts(TfootTagOpenContext.class); 6950 } 6951 public List<TfootContext> tfoot() { 6952 return getRuleContexts(TfootContext.class); 6953 } 6954 public List<JavadocInlineTagContext> javadocInlineTag() { 6955 return getRuleContexts(JavadocInlineTagContext.class); 6956 } 6957 public List<HtmlCommentContext> htmlComment() { 6958 return getRuleContexts(HtmlCommentContext.class); 6959 } 6960 public OptionContext option(int i) { 6961 return getRuleContext(OptionContext.class,i); 6962 } 6963 public TrContext tr(int i) { 6964 return getRuleContext(TrContext.class,i); 6965 } 6966 public HtmlCommentContext htmlComment(int i) { 6967 return getRuleContext(HtmlCommentContext.class,i); 6968 } 6969 public List<TdContext> td() { 6970 return getRuleContexts(TdContext.class); 6971 } 6972 public List<BodyTagOpenContext> bodyTagOpen() { 6973 return getRuleContexts(BodyTagOpenContext.class); 6974 } 6975 public HtmlContext html(int i) { 6976 return getRuleContext(HtmlContext.class,i); 6977 } 6978 public BodyTagOpenContext bodyTagOpen(int i) { 6979 return getRuleContext(BodyTagOpenContext.class,i); 6980 } 6981 public DdTagOpenContext ddTagOpen(int i) { 6982 return getRuleContext(DdTagOpenContext.class,i); 6983 } 6984 public List<HtmlTagContext> htmlTag() { 6985 return getRuleContexts(HtmlTagContext.class); 6986 } 6987 public ParagraphContext paragraph(int i) { 6988 return getRuleContext(ParagraphContext.class,i); 6989 } 6990 public List<TdTagOpenContext> tdTagOpen() { 6991 return getRuleContexts(TdTagOpenContext.class); 6992 } 6993 public OptionTagOpenContext optionTagOpen(int i) { 6994 return getRuleContext(OptionTagOpenContext.class,i); 6995 } 6996 public LiTagOpenContext liTagOpen(int i) { 6997 return getRuleContext(LiTagOpenContext.class,i); 6998 } 6999 public TdContext td(int i) { 7000 return getRuleContext(TdContext.class,i); 7001 } 7002 public List<ParagraphContext> paragraph() { 7003 return getRuleContexts(ParagraphContext.class); 7004 } 7005 public HtmlTagContext htmlTag(int i) { 7006 return getRuleContext(HtmlTagContext.class,i); 7007 } 7008 public List<SingletonTagContext> singletonTag() { 7009 return getRuleContexts(SingletonTagContext.class); 7010 } 7011 public HeadTagOpenContext headTagOpen(int i) { 7012 return getRuleContext(HeadTagOpenContext.class,i); 7013 } 7014 public TrTagOpenContext trTagOpen(int i) { 7015 return getRuleContext(TrTagOpenContext.class,i); 7016 } 7017 public List<HtmlContext> html() { 7018 return getRuleContexts(HtmlContext.class); 7019 } 7020 public JavadocInlineTagContext javadocInlineTag(int i) { 7021 return getRuleContext(JavadocInlineTagContext.class,i); 7022 } 7023 public List<ThContext> th() { 7024 return getRuleContexts(ThContext.class); 7025 } 7026 public PTagOpenContext pTagOpen(int i) { 7027 return getRuleContext(PTagOpenContext.class,i); 7028 } 7029 public TerminalNode LEADING_ASTERISK(int i) { 7030 return getToken(JavadocParser.LEADING_ASTERISK, i); 7031 } 7032 public List<TrTagOpenContext> trTagOpen() { 7033 return getRuleContexts(TrTagOpenContext.class); 7034 } 7035 public List<TbodyContext> tbody() { 7036 return getRuleContexts(TbodyContext.class); 7037 } 7038 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7039 public List<TheadTagOpenContext> theadTagOpen() { 7040 return getRuleContexts(TheadTagOpenContext.class); 7041 } 7042 public List<HeadContext> head() { 7043 return getRuleContexts(HeadContext.class); 7044 } 7045 public TerminalNode NEWLINE(int i) { 7046 return getToken(JavadocParser.NEWLINE, i); 7047 } 7048 public TextContext text(int i) { 7049 return getRuleContext(TextContext.class,i); 7050 } 7051 public List<BodyContext> body() { 7052 return getRuleContexts(BodyContext.class); 7053 } 7054 public List<OptionTagOpenContext> optionTagOpen() { 7055 return getRuleContexts(OptionTagOpenContext.class); 7056 } 7057 public List<TextContext> text() { 7058 return getRuleContexts(TextContext.class); 7059 } 7060 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7061 public TbodyTagOpenContext tbodyTagOpen(int i) { 7062 return getRuleContext(TbodyTagOpenContext.class,i); 7063 } 7064 public List<DdContext> dd() { 7065 return getRuleContexts(DdContext.class); 7066 } 7067 public TheadTagOpenContext theadTagOpen(int i) { 7068 return getRuleContext(TheadTagOpenContext.class,i); 7069 } 7070 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7071 return getRuleContext(ColgroupTagOpenContext.class,i); 7072 } 7073 public List<LiTagOpenContext> liTagOpen() { 7074 return getRuleContexts(LiTagOpenContext.class); 7075 } 7076 public DdContext dd(int i) { 7077 return getRuleContext(DdContext.class,i); 7078 } 7079 public List<OptionContext> option() { 7080 return getRuleContexts(OptionContext.class); 7081 } 7082 public TheadContext thead(int i) { 7083 return getRuleContext(TheadContext.class,i); 7084 } 7085 public BodyContext body(int i) { 7086 return getRuleContext(BodyContext.class,i); 7087 } 7088 public ThContext th(int i) { 7089 return getRuleContext(ThContext.class,i); 7090 } 7091 public List<PTagOpenContext> pTagOpen() { 7092 return getRuleContexts(PTagOpenContext.class); 7093 } 7094 public HtmlTagOpenContext htmlTagOpen(int i) { 7095 return getRuleContext(HtmlTagOpenContext.class,i); 7096 } 7097 public SingletonTagContext singletonTag(int i) { 7098 return getRuleContext(SingletonTagContext.class,i); 7099 } 7100 public DtTagCloseContext dtTagClose() { 7101 return getRuleContext(DtTagCloseContext.class,0); 7102 } 7103 public TfootContext tfoot(int i) { 7104 return getRuleContext(TfootContext.class,i); 7105 } 7106 public DtContext(ParserRuleContext parent, int invokingState) { 7107 super(parent, invokingState); 7108 } 7109 @Override public int getRuleIndex() { return RULE_dt; } 7110 @Override 7111 public void enterRule(ParseTreeListener listener) { 7112 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7113 } 7114 @Override 7115 public void exitRule(ParseTreeListener listener) { 7116 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7117 } 7118 @Override 7119 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7120 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7121 else return visitor.visitChildren(this); 7122 } 7123 } 7124 7125 public final DtContext dt() throws RecognitionException { 7126 DtContext _localctx = new DtContext(_ctx, getState()); 7127 enterRule(_localctx, 64, RULE_dt); 7128 try { 7129 int _alt; 7130 enterOuterAlt(_localctx, 1); 7131 { 7132 setState(882); dtTagOpen(); 7133 setState(922); 7134 _errHandler.sync(this); 7135 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7136 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7137 if ( _alt==1 ) { 7138 { 7139 setState(920); 7140 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7141 case 1: 7142 { 7143 setState(883); htmlTag(); 7144 } 7145 break; 7146 7147 case 2: 7148 { 7149 setState(884); singletonTag(); 7150 } 7151 break; 7152 7153 case 3: 7154 { 7155 setState(885); paragraph(); 7156 } 7157 break; 7158 7159 case 4: 7160 { 7161 setState(886); li(); 7162 } 7163 break; 7164 7165 case 5: 7166 { 7167 setState(887); tr(); 7168 } 7169 break; 7170 7171 case 6: 7172 { 7173 setState(888); td(); 7174 } 7175 break; 7176 7177 case 7: 7178 { 7179 setState(889); th(); 7180 } 7181 break; 7182 7183 case 8: 7184 { 7185 setState(890); body(); 7186 } 7187 break; 7188 7189 case 9: 7190 { 7191 setState(891); colgroup(); 7192 } 7193 break; 7194 7195 case 10: 7196 { 7197 setState(892); dd(); 7198 } 7199 break; 7200 7201 case 11: 7202 { 7203 setState(893); head(); 7204 } 7205 break; 7206 7207 case 12: 7208 { 7209 setState(894); html(); 7210 } 7211 break; 7212 7213 case 13: 7214 { 7215 setState(895); option(); 7216 } 7217 break; 7218 7219 case 14: 7220 { 7221 setState(896); tbody(); 7222 } 7223 break; 7224 7225 case 15: 7226 { 7227 setState(897); thead(); 7228 } 7229 break; 7230 7231 case 16: 7232 { 7233 setState(898); tfoot(); 7234 } 7235 break; 7236 7237 case 17: 7238 { 7239 setState(899); pTagOpen(); 7240 } 7241 break; 7242 7243 case 18: 7244 { 7245 setState(900); liTagOpen(); 7246 } 7247 break; 7248 7249 case 19: 7250 { 7251 setState(901); trTagOpen(); 7252 } 7253 break; 7254 7255 case 20: 7256 { 7257 setState(902); tdTagOpen(); 7258 } 7259 break; 7260 7261 case 21: 7262 { 7263 setState(903); thTagOpen(); 7264 } 7265 break; 7266 7267 case 22: 7268 { 7269 setState(904); bodyTagOpen(); 7270 } 7271 break; 7272 7273 case 23: 7274 { 7275 setState(905); colgroupTagOpen(); 7276 } 7277 break; 7278 7279 case 24: 7280 { 7281 setState(906); ddTagOpen(); 7282 } 7283 break; 7284 7285 case 25: 7286 { 7287 setState(907); headTagOpen(); 7288 } 7289 break; 7290 7291 case 26: 7292 { 7293 setState(908); htmlTagOpen(); 7294 } 7295 break; 7296 7297 case 27: 7298 { 7299 setState(909); optionTagOpen(); 7300 } 7301 break; 7302 7303 case 28: 7304 { 7305 setState(910); tbodyTagOpen(); 7306 } 7307 break; 7308 7309 case 29: 7310 { 7311 setState(911); theadTagOpen(); 7312 } 7313 break; 7314 7315 case 30: 7316 { 7317 setState(912); tfootTagOpen(); 7318 } 7319 break; 7320 7321 case 31: 7322 { 7323 { 7324 setState(913); 7325 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7326 setState(914); match(LEADING_ASTERISK); 7327 } 7328 } 7329 break; 7330 7331 case 32: 7332 { 7333 setState(915); htmlComment(); 7334 } 7335 break; 7336 7337 case 33: 7338 { 7339 setState(916); match(CDATA); 7340 } 7341 break; 7342 7343 case 34: 7344 { 7345 setState(917); match(NEWLINE); 7346 } 7347 break; 7348 7349 case 35: 7350 { 7351 setState(918); text(); 7352 } 7353 break; 7354 7355 case 36: 7356 { 7357 setState(919); javadocInlineTag(); 7358 } 7359 break; 7360 } 7361 } 7362 } 7363 setState(924); 7364 _errHandler.sync(this); 7365 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7366 } 7367 setState(925); dtTagClose(); 7368 } 7369 } 7370 catch (RecognitionException re) { 7371 _localctx.exception = re; 7372 _errHandler.reportError(this, re); 7373 _errHandler.recover(this, re); 7374 } 7375 finally { 7376 exitRule(); 7377 } 7378 return _localctx; 7379 } 7380 7381 public static class HeadTagOpenContext extends ParserRuleContext { 7382 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7383 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7384 public TerminalNode NEWLINE(int i) { 7385 return getToken(JavadocParser.NEWLINE, i); 7386 } 7387 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7388 public List<AttributeContext> attribute() { 7389 return getRuleContexts(AttributeContext.class); 7390 } 7391 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7392 public AttributeContext attribute(int i) { 7393 return getRuleContext(AttributeContext.class,i); 7394 } 7395 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7396 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7397 public TerminalNode LEADING_ASTERISK(int i) { 7398 return getToken(JavadocParser.LEADING_ASTERISK, i); 7399 } 7400 public TerminalNode WS(int i) { 7401 return getToken(JavadocParser.WS, i); 7402 } 7403 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7404 super(parent, invokingState); 7405 } 7406 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7407 @Override 7408 public void enterRule(ParseTreeListener listener) { 7409 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7410 } 7411 @Override 7412 public void exitRule(ParseTreeListener listener) { 7413 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7414 } 7415 @Override 7416 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7417 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7418 else return visitor.visitChildren(this); 7419 } 7420 } 7421 7422 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7423 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7424 enterRule(_localctx, 66, RULE_headTagOpen); 7425 int _la; 7426 try { 7427 enterOuterAlt(_localctx, 1); 7428 { 7429 setState(927); match(OPEN); 7430 setState(928); match(HEAD_HTML_TAG_NAME); 7431 setState(935); 7432 _errHandler.sync(this); 7433 _la = _input.LA(1); 7434 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7435 { 7436 setState(933); 7437 switch (_input.LA(1)) { 7438 case HTML_TAG_NAME: 7439 { 7440 setState(929); attribute(); 7441 } 7442 break; 7443 case NEWLINE: 7444 { 7445 setState(930); match(NEWLINE); 7446 } 7447 break; 7448 case LEADING_ASTERISK: 7449 { 7450 setState(931); match(LEADING_ASTERISK); 7451 } 7452 break; 7453 case WS: 7454 { 7455 setState(932); match(WS); 7456 } 7457 break; 7458 default: 7459 throw new NoViableAltException(this); 7460 } 7461 } 7462 setState(937); 7463 _errHandler.sync(this); 7464 _la = _input.LA(1); 7465 } 7466 setState(938); match(CLOSE); 7467 } 7468 } 7469 catch (RecognitionException re) { 7470 _localctx.exception = re; 7471 _errHandler.reportError(this, re); 7472 _errHandler.recover(this, re); 7473 } 7474 finally { 7475 exitRule(); 7476 } 7477 return _localctx; 7478 } 7479 7480 public static class HeadTagCloseContext extends ParserRuleContext { 7481 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7482 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7483 public TerminalNode NEWLINE(int i) { 7484 return getToken(JavadocParser.NEWLINE, i); 7485 } 7486 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7487 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7488 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7489 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7490 public TerminalNode LEADING_ASTERISK(int i) { 7491 return getToken(JavadocParser.LEADING_ASTERISK, i); 7492 } 7493 public TerminalNode WS(int i) { 7494 return getToken(JavadocParser.WS, i); 7495 } 7496 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7497 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7498 super(parent, invokingState); 7499 } 7500 @Override public int getRuleIndex() { return RULE_headTagClose; } 7501 @Override 7502 public void enterRule(ParseTreeListener listener) { 7503 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7504 } 7505 @Override 7506 public void exitRule(ParseTreeListener listener) { 7507 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7508 } 7509 @Override 7510 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7511 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7512 else return visitor.visitChildren(this); 7513 } 7514 } 7515 7516 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7517 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7518 enterRule(_localctx, 68, RULE_headTagClose); 7519 int _la; 7520 try { 7521 enterOuterAlt(_localctx, 1); 7522 { 7523 setState(940); match(OPEN); 7524 setState(941); match(SLASH); 7525 setState(942); match(HEAD_HTML_TAG_NAME); 7526 setState(946); 7527 _errHandler.sync(this); 7528 _la = _input.LA(1); 7529 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7530 { 7531 { 7532 setState(943); 7533 _la = _input.LA(1); 7534 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7535 _errHandler.recoverInline(this); 7536 } 7537 consume(); 7538 } 7539 } 7540 setState(948); 7541 _errHandler.sync(this); 7542 _la = _input.LA(1); 7543 } 7544 setState(949); match(CLOSE); 7545 } 7546 } 7547 catch (RecognitionException re) { 7548 _localctx.exception = re; 7549 _errHandler.reportError(this, re); 7550 _errHandler.recover(this, re); 7551 } 7552 finally { 7553 exitRule(); 7554 } 7555 return _localctx; 7556 } 7557 7558 public static class HeadContext extends ParserRuleContext { 7559 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7560 return getRuleContexts(ColgroupTagOpenContext.class); 7561 } 7562 public TbodyContext tbody(int i) { 7563 return getRuleContext(TbodyContext.class,i); 7564 } 7565 public TerminalNode CDATA(int i) { 7566 return getToken(JavadocParser.CDATA, i); 7567 } 7568 public TfootTagOpenContext tfootTagOpen(int i) { 7569 return getRuleContext(TfootTagOpenContext.class,i); 7570 } 7571 public List<DtTagOpenContext> dtTagOpen() { 7572 return getRuleContexts(DtTagOpenContext.class); 7573 } 7574 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7575 public List<ColgroupContext> colgroup() { 7576 return getRuleContexts(ColgroupContext.class); 7577 } 7578 public List<TrContext> tr() { 7579 return getRuleContexts(TrContext.class); 7580 } 7581 public List<LiContext> li() { 7582 return getRuleContexts(LiContext.class); 7583 } 7584 public ThTagOpenContext thTagOpen(int i) { 7585 return getRuleContext(ThTagOpenContext.class,i); 7586 } 7587 public List<DdTagOpenContext> ddTagOpen() { 7588 return getRuleContexts(DdTagOpenContext.class); 7589 } 7590 public ColgroupContext colgroup(int i) { 7591 return getRuleContext(ColgroupContext.class,i); 7592 } 7593 public TdTagOpenContext tdTagOpen(int i) { 7594 return getRuleContext(TdTagOpenContext.class,i); 7595 } 7596 public List<ThTagOpenContext> thTagOpen() { 7597 return getRuleContexts(ThTagOpenContext.class); 7598 } 7599 public HeadTagOpenContext headTagOpen() { 7600 return getRuleContext(HeadTagOpenContext.class,0); 7601 } 7602 public List<HtmlTagOpenContext> htmlTagOpen() { 7603 return getRuleContexts(HtmlTagOpenContext.class); 7604 } 7605 public List<TbodyTagOpenContext> tbodyTagOpen() { 7606 return getRuleContexts(TbodyTagOpenContext.class); 7607 } 7608 public List<TheadContext> thead() { 7609 return getRuleContexts(TheadContext.class); 7610 } 7611 public LiContext li(int i) { 7612 return getRuleContext(LiContext.class,i); 7613 } 7614 public List<TfootTagOpenContext> tfootTagOpen() { 7615 return getRuleContexts(TfootTagOpenContext.class); 7616 } 7617 public List<TfootContext> tfoot() { 7618 return getRuleContexts(TfootContext.class); 7619 } 7620 public List<JavadocInlineTagContext> javadocInlineTag() { 7621 return getRuleContexts(JavadocInlineTagContext.class); 7622 } 7623 public List<HtmlCommentContext> htmlComment() { 7624 return getRuleContexts(HtmlCommentContext.class); 7625 } 7626 public OptionContext option(int i) { 7627 return getRuleContext(OptionContext.class,i); 7628 } 7629 public TrContext tr(int i) { 7630 return getRuleContext(TrContext.class,i); 7631 } 7632 public List<DtContext> dt() { 7633 return getRuleContexts(DtContext.class); 7634 } 7635 public HtmlCommentContext htmlComment(int i) { 7636 return getRuleContext(HtmlCommentContext.class,i); 7637 } 7638 public List<TdContext> td() { 7639 return getRuleContexts(TdContext.class); 7640 } 7641 public List<BodyTagOpenContext> bodyTagOpen() { 7642 return getRuleContexts(BodyTagOpenContext.class); 7643 } 7644 public DtTagOpenContext dtTagOpen(int i) { 7645 return getRuleContext(DtTagOpenContext.class,i); 7646 } 7647 public HtmlContext html(int i) { 7648 return getRuleContext(HtmlContext.class,i); 7649 } 7650 public BodyTagOpenContext bodyTagOpen(int i) { 7651 return getRuleContext(BodyTagOpenContext.class,i); 7652 } 7653 public DdTagOpenContext ddTagOpen(int i) { 7654 return getRuleContext(DdTagOpenContext.class,i); 7655 } 7656 public List<HtmlTagContext> htmlTag() { 7657 return getRuleContexts(HtmlTagContext.class); 7658 } 7659 public ParagraphContext paragraph(int i) { 7660 return getRuleContext(ParagraphContext.class,i); 7661 } 7662 public List<TdTagOpenContext> tdTagOpen() { 7663 return getRuleContexts(TdTagOpenContext.class); 7664 } 7665 public OptionTagOpenContext optionTagOpen(int i) { 7666 return getRuleContext(OptionTagOpenContext.class,i); 7667 } 7668 public LiTagOpenContext liTagOpen(int i) { 7669 return getRuleContext(LiTagOpenContext.class,i); 7670 } 7671 public TdContext td(int i) { 7672 return getRuleContext(TdContext.class,i); 7673 } 7674 public List<ParagraphContext> paragraph() { 7675 return getRuleContexts(ParagraphContext.class); 7676 } 7677 public HtmlTagContext htmlTag(int i) { 7678 return getRuleContext(HtmlTagContext.class,i); 7679 } 7680 public List<SingletonTagContext> singletonTag() { 7681 return getRuleContexts(SingletonTagContext.class); 7682 } 7683 public TrTagOpenContext trTagOpen(int i) { 7684 return getRuleContext(TrTagOpenContext.class,i); 7685 } 7686 public List<HtmlContext> html() { 7687 return getRuleContexts(HtmlContext.class); 7688 } 7689 public JavadocInlineTagContext javadocInlineTag(int i) { 7690 return getRuleContext(JavadocInlineTagContext.class,i); 7691 } 7692 public List<ThContext> th() { 7693 return getRuleContexts(ThContext.class); 7694 } 7695 public DtContext dt(int i) { 7696 return getRuleContext(DtContext.class,i); 7697 } 7698 public PTagOpenContext pTagOpen(int i) { 7699 return getRuleContext(PTagOpenContext.class,i); 7700 } 7701 public TerminalNode LEADING_ASTERISK(int i) { 7702 return getToken(JavadocParser.LEADING_ASTERISK, i); 7703 } 7704 public HeadTagCloseContext headTagClose() { 7705 return getRuleContext(HeadTagCloseContext.class,0); 7706 } 7707 public List<TrTagOpenContext> trTagOpen() { 7708 return getRuleContexts(TrTagOpenContext.class); 7709 } 7710 public List<TbodyContext> tbody() { 7711 return getRuleContexts(TbodyContext.class); 7712 } 7713 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7714 public List<TheadTagOpenContext> theadTagOpen() { 7715 return getRuleContexts(TheadTagOpenContext.class); 7716 } 7717 public TerminalNode NEWLINE(int i) { 7718 return getToken(JavadocParser.NEWLINE, i); 7719 } 7720 public TextContext text(int i) { 7721 return getRuleContext(TextContext.class,i); 7722 } 7723 public List<BodyContext> body() { 7724 return getRuleContexts(BodyContext.class); 7725 } 7726 public List<OptionTagOpenContext> optionTagOpen() { 7727 return getRuleContexts(OptionTagOpenContext.class); 7728 } 7729 public List<TextContext> text() { 7730 return getRuleContexts(TextContext.class); 7731 } 7732 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7733 public TbodyTagOpenContext tbodyTagOpen(int i) { 7734 return getRuleContext(TbodyTagOpenContext.class,i); 7735 } 7736 public List<DdContext> dd() { 7737 return getRuleContexts(DdContext.class); 7738 } 7739 public TheadTagOpenContext theadTagOpen(int i) { 7740 return getRuleContext(TheadTagOpenContext.class,i); 7741 } 7742 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7743 return getRuleContext(ColgroupTagOpenContext.class,i); 7744 } 7745 public List<LiTagOpenContext> liTagOpen() { 7746 return getRuleContexts(LiTagOpenContext.class); 7747 } 7748 public DdContext dd(int i) { 7749 return getRuleContext(DdContext.class,i); 7750 } 7751 public List<OptionContext> option() { 7752 return getRuleContexts(OptionContext.class); 7753 } 7754 public TheadContext thead(int i) { 7755 return getRuleContext(TheadContext.class,i); 7756 } 7757 public BodyContext body(int i) { 7758 return getRuleContext(BodyContext.class,i); 7759 } 7760 public ThContext th(int i) { 7761 return getRuleContext(ThContext.class,i); 7762 } 7763 public List<PTagOpenContext> pTagOpen() { 7764 return getRuleContexts(PTagOpenContext.class); 7765 } 7766 public HtmlTagOpenContext htmlTagOpen(int i) { 7767 return getRuleContext(HtmlTagOpenContext.class,i); 7768 } 7769 public SingletonTagContext singletonTag(int i) { 7770 return getRuleContext(SingletonTagContext.class,i); 7771 } 7772 public TfootContext tfoot(int i) { 7773 return getRuleContext(TfootContext.class,i); 7774 } 7775 public HeadContext(ParserRuleContext parent, int invokingState) { 7776 super(parent, invokingState); 7777 } 7778 @Override public int getRuleIndex() { return RULE_head; } 7779 @Override 7780 public void enterRule(ParseTreeListener listener) { 7781 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 7782 } 7783 @Override 7784 public void exitRule(ParseTreeListener listener) { 7785 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 7786 } 7787 @Override 7788 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7789 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 7790 else return visitor.visitChildren(this); 7791 } 7792 } 7793 7794 public final HeadContext head() throws RecognitionException { 7795 HeadContext _localctx = new HeadContext(_ctx, getState()); 7796 enterRule(_localctx, 70, RULE_head); 7797 try { 7798 int _alt; 7799 enterOuterAlt(_localctx, 1); 7800 { 7801 setState(951); headTagOpen(); 7802 setState(991); 7803 _errHandler.sync(this); 7804 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 7805 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7806 if ( _alt==1 ) { 7807 { 7808 setState(989); 7809 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 7810 case 1: 7811 { 7812 setState(952); htmlTag(); 7813 } 7814 break; 7815 7816 case 2: 7817 { 7818 setState(953); singletonTag(); 7819 } 7820 break; 7821 7822 case 3: 7823 { 7824 setState(954); paragraph(); 7825 } 7826 break; 7827 7828 case 4: 7829 { 7830 setState(955); li(); 7831 } 7832 break; 7833 7834 case 5: 7835 { 7836 setState(956); tr(); 7837 } 7838 break; 7839 7840 case 6: 7841 { 7842 setState(957); td(); 7843 } 7844 break; 7845 7846 case 7: 7847 { 7848 setState(958); th(); 7849 } 7850 break; 7851 7852 case 8: 7853 { 7854 setState(959); body(); 7855 } 7856 break; 7857 7858 case 9: 7859 { 7860 setState(960); colgroup(); 7861 } 7862 break; 7863 7864 case 10: 7865 { 7866 setState(961); dd(); 7867 } 7868 break; 7869 7870 case 11: 7871 { 7872 setState(962); dt(); 7873 } 7874 break; 7875 7876 case 12: 7877 { 7878 setState(963); html(); 7879 } 7880 break; 7881 7882 case 13: 7883 { 7884 setState(964); option(); 7885 } 7886 break; 7887 7888 case 14: 7889 { 7890 setState(965); tbody(); 7891 } 7892 break; 7893 7894 case 15: 7895 { 7896 setState(966); thead(); 7897 } 7898 break; 7899 7900 case 16: 7901 { 7902 setState(967); tfoot(); 7903 } 7904 break; 7905 7906 case 17: 7907 { 7908 setState(968); pTagOpen(); 7909 } 7910 break; 7911 7912 case 18: 7913 { 7914 setState(969); liTagOpen(); 7915 } 7916 break; 7917 7918 case 19: 7919 { 7920 setState(970); trTagOpen(); 7921 } 7922 break; 7923 7924 case 20: 7925 { 7926 setState(971); tdTagOpen(); 7927 } 7928 break; 7929 7930 case 21: 7931 { 7932 setState(972); thTagOpen(); 7933 } 7934 break; 7935 7936 case 22: 7937 { 7938 setState(973); bodyTagOpen(); 7939 } 7940 break; 7941 7942 case 23: 7943 { 7944 setState(974); colgroupTagOpen(); 7945 } 7946 break; 7947 7948 case 24: 7949 { 7950 setState(975); ddTagOpen(); 7951 } 7952 break; 7953 7954 case 25: 7955 { 7956 setState(976); dtTagOpen(); 7957 } 7958 break; 7959 7960 case 26: 7961 { 7962 setState(977); htmlTagOpen(); 7963 } 7964 break; 7965 7966 case 27: 7967 { 7968 setState(978); optionTagOpen(); 7969 } 7970 break; 7971 7972 case 28: 7973 { 7974 setState(979); tbodyTagOpen(); 7975 } 7976 break; 7977 7978 case 29: 7979 { 7980 setState(980); theadTagOpen(); 7981 } 7982 break; 7983 7984 case 30: 7985 { 7986 setState(981); tfootTagOpen(); 7987 } 7988 break; 7989 7990 case 31: 7991 { 7992 { 7993 setState(982); 7994 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7995 setState(983); match(LEADING_ASTERISK); 7996 } 7997 } 7998 break; 7999 8000 case 32: 8001 { 8002 setState(984); htmlComment(); 8003 } 8004 break; 8005 8006 case 33: 8007 { 8008 setState(985); match(CDATA); 8009 } 8010 break; 8011 8012 case 34: 8013 { 8014 setState(986); match(NEWLINE); 8015 } 8016 break; 8017 8018 case 35: 8019 { 8020 setState(987); text(); 8021 } 8022 break; 8023 8024 case 36: 8025 { 8026 setState(988); javadocInlineTag(); 8027 } 8028 break; 8029 } 8030 } 8031 } 8032 setState(993); 8033 _errHandler.sync(this); 8034 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8035 } 8036 setState(994); headTagClose(); 8037 } 8038 } 8039 catch (RecognitionException re) { 8040 _localctx.exception = re; 8041 _errHandler.reportError(this, re); 8042 _errHandler.recover(this, re); 8043 } 8044 finally { 8045 exitRule(); 8046 } 8047 return _localctx; 8048 } 8049 8050 public static class HtmlTagOpenContext extends ParserRuleContext { 8051 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8052 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8053 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8054 public TerminalNode NEWLINE(int i) { 8055 return getToken(JavadocParser.NEWLINE, i); 8056 } 8057 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8058 public List<AttributeContext> attribute() { 8059 return getRuleContexts(AttributeContext.class); 8060 } 8061 public AttributeContext attribute(int i) { 8062 return getRuleContext(AttributeContext.class,i); 8063 } 8064 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8065 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8066 public TerminalNode LEADING_ASTERISK(int i) { 8067 return getToken(JavadocParser.LEADING_ASTERISK, i); 8068 } 8069 public TerminalNode WS(int i) { 8070 return getToken(JavadocParser.WS, i); 8071 } 8072 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8073 super(parent, invokingState); 8074 } 8075 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8076 @Override 8077 public void enterRule(ParseTreeListener listener) { 8078 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8079 } 8080 @Override 8081 public void exitRule(ParseTreeListener listener) { 8082 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8083 } 8084 @Override 8085 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8086 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8087 else return visitor.visitChildren(this); 8088 } 8089 } 8090 8091 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8092 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8093 enterRule(_localctx, 72, RULE_htmlTagOpen); 8094 int _la; 8095 try { 8096 enterOuterAlt(_localctx, 1); 8097 { 8098 setState(996); match(OPEN); 8099 setState(997); match(HTML_HTML_TAG_NAME); 8100 setState(1004); 8101 _errHandler.sync(this); 8102 _la = _input.LA(1); 8103 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8104 { 8105 setState(1002); 8106 switch (_input.LA(1)) { 8107 case HTML_TAG_NAME: 8108 { 8109 setState(998); attribute(); 8110 } 8111 break; 8112 case NEWLINE: 8113 { 8114 setState(999); match(NEWLINE); 8115 } 8116 break; 8117 case LEADING_ASTERISK: 8118 { 8119 setState(1000); match(LEADING_ASTERISK); 8120 } 8121 break; 8122 case WS: 8123 { 8124 setState(1001); match(WS); 8125 } 8126 break; 8127 default: 8128 throw new NoViableAltException(this); 8129 } 8130 } 8131 setState(1006); 8132 _errHandler.sync(this); 8133 _la = _input.LA(1); 8134 } 8135 setState(1007); match(CLOSE); 8136 } 8137 } 8138 catch (RecognitionException re) { 8139 _localctx.exception = re; 8140 _errHandler.reportError(this, re); 8141 _errHandler.recover(this, re); 8142 } 8143 finally { 8144 exitRule(); 8145 } 8146 return _localctx; 8147 } 8148 8149 public static class HtmlTagCloseContext extends ParserRuleContext { 8150 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8151 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8152 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8153 public TerminalNode NEWLINE(int i) { 8154 return getToken(JavadocParser.NEWLINE, i); 8155 } 8156 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8157 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8158 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8159 public TerminalNode LEADING_ASTERISK(int i) { 8160 return getToken(JavadocParser.LEADING_ASTERISK, i); 8161 } 8162 public TerminalNode WS(int i) { 8163 return getToken(JavadocParser.WS, i); 8164 } 8165 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8166 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8167 super(parent, invokingState); 8168 } 8169 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8170 @Override 8171 public void enterRule(ParseTreeListener listener) { 8172 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8173 } 8174 @Override 8175 public void exitRule(ParseTreeListener listener) { 8176 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8177 } 8178 @Override 8179 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8180 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8181 else return visitor.visitChildren(this); 8182 } 8183 } 8184 8185 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8186 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8187 enterRule(_localctx, 74, RULE_htmlTagClose); 8188 int _la; 8189 try { 8190 enterOuterAlt(_localctx, 1); 8191 { 8192 setState(1009); match(OPEN); 8193 setState(1010); match(SLASH); 8194 setState(1011); match(HTML_HTML_TAG_NAME); 8195 setState(1015); 8196 _errHandler.sync(this); 8197 _la = _input.LA(1); 8198 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8199 { 8200 { 8201 setState(1012); 8202 _la = _input.LA(1); 8203 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8204 _errHandler.recoverInline(this); 8205 } 8206 consume(); 8207 } 8208 } 8209 setState(1017); 8210 _errHandler.sync(this); 8211 _la = _input.LA(1); 8212 } 8213 setState(1018); match(CLOSE); 8214 } 8215 } 8216 catch (RecognitionException re) { 8217 _localctx.exception = re; 8218 _errHandler.reportError(this, re); 8219 _errHandler.recover(this, re); 8220 } 8221 finally { 8222 exitRule(); 8223 } 8224 return _localctx; 8225 } 8226 8227 public static class HtmlContext extends ParserRuleContext { 8228 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8229 return getRuleContexts(ColgroupTagOpenContext.class); 8230 } 8231 public TbodyContext tbody(int i) { 8232 return getRuleContext(TbodyContext.class,i); 8233 } 8234 public HtmlTagCloseContext htmlTagClose() { 8235 return getRuleContext(HtmlTagCloseContext.class,0); 8236 } 8237 public TerminalNode CDATA(int i) { 8238 return getToken(JavadocParser.CDATA, i); 8239 } 8240 public TfootTagOpenContext tfootTagOpen(int i) { 8241 return getRuleContext(TfootTagOpenContext.class,i); 8242 } 8243 public List<DtTagOpenContext> dtTagOpen() { 8244 return getRuleContexts(DtTagOpenContext.class); 8245 } 8246 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8247 public List<ColgroupContext> colgroup() { 8248 return getRuleContexts(ColgroupContext.class); 8249 } 8250 public HeadContext head(int i) { 8251 return getRuleContext(HeadContext.class,i); 8252 } 8253 public List<TrContext> tr() { 8254 return getRuleContexts(TrContext.class); 8255 } 8256 public List<LiContext> li() { 8257 return getRuleContexts(LiContext.class); 8258 } 8259 public ThTagOpenContext thTagOpen(int i) { 8260 return getRuleContext(ThTagOpenContext.class,i); 8261 } 8262 public List<DdTagOpenContext> ddTagOpen() { 8263 return getRuleContexts(DdTagOpenContext.class); 8264 } 8265 public ColgroupContext colgroup(int i) { 8266 return getRuleContext(ColgroupContext.class,i); 8267 } 8268 public TdTagOpenContext tdTagOpen(int i) { 8269 return getRuleContext(TdTagOpenContext.class,i); 8270 } 8271 public List<ThTagOpenContext> thTagOpen() { 8272 return getRuleContexts(ThTagOpenContext.class); 8273 } 8274 public List<HeadTagOpenContext> headTagOpen() { 8275 return getRuleContexts(HeadTagOpenContext.class); 8276 } 8277 public HtmlTagOpenContext htmlTagOpen() { 8278 return getRuleContext(HtmlTagOpenContext.class,0); 8279 } 8280 public List<TbodyTagOpenContext> tbodyTagOpen() { 8281 return getRuleContexts(TbodyTagOpenContext.class); 8282 } 8283 public List<TheadContext> thead() { 8284 return getRuleContexts(TheadContext.class); 8285 } 8286 public LiContext li(int i) { 8287 return getRuleContext(LiContext.class,i); 8288 } 8289 public List<TfootTagOpenContext> tfootTagOpen() { 8290 return getRuleContexts(TfootTagOpenContext.class); 8291 } 8292 public List<TfootContext> tfoot() { 8293 return getRuleContexts(TfootContext.class); 8294 } 8295 public List<JavadocInlineTagContext> javadocInlineTag() { 8296 return getRuleContexts(JavadocInlineTagContext.class); 8297 } 8298 public List<HtmlCommentContext> htmlComment() { 8299 return getRuleContexts(HtmlCommentContext.class); 8300 } 8301 public OptionContext option(int i) { 8302 return getRuleContext(OptionContext.class,i); 8303 } 8304 public TrContext tr(int i) { 8305 return getRuleContext(TrContext.class,i); 8306 } 8307 public List<DtContext> dt() { 8308 return getRuleContexts(DtContext.class); 8309 } 8310 public HtmlCommentContext htmlComment(int i) { 8311 return getRuleContext(HtmlCommentContext.class,i); 8312 } 8313 public List<TdContext> td() { 8314 return getRuleContexts(TdContext.class); 8315 } 8316 public List<BodyTagOpenContext> bodyTagOpen() { 8317 return getRuleContexts(BodyTagOpenContext.class); 8318 } 8319 public DtTagOpenContext dtTagOpen(int i) { 8320 return getRuleContext(DtTagOpenContext.class,i); 8321 } 8322 public BodyTagOpenContext bodyTagOpen(int i) { 8323 return getRuleContext(BodyTagOpenContext.class,i); 8324 } 8325 public DdTagOpenContext ddTagOpen(int i) { 8326 return getRuleContext(DdTagOpenContext.class,i); 8327 } 8328 public List<HtmlTagContext> htmlTag() { 8329 return getRuleContexts(HtmlTagContext.class); 8330 } 8331 public ParagraphContext paragraph(int i) { 8332 return getRuleContext(ParagraphContext.class,i); 8333 } 8334 public List<TdTagOpenContext> tdTagOpen() { 8335 return getRuleContexts(TdTagOpenContext.class); 8336 } 8337 public OptionTagOpenContext optionTagOpen(int i) { 8338 return getRuleContext(OptionTagOpenContext.class,i); 8339 } 8340 public LiTagOpenContext liTagOpen(int i) { 8341 return getRuleContext(LiTagOpenContext.class,i); 8342 } 8343 public TdContext td(int i) { 8344 return getRuleContext(TdContext.class,i); 8345 } 8346 public List<ParagraphContext> paragraph() { 8347 return getRuleContexts(ParagraphContext.class); 8348 } 8349 public HtmlTagContext htmlTag(int i) { 8350 return getRuleContext(HtmlTagContext.class,i); 8351 } 8352 public List<SingletonTagContext> singletonTag() { 8353 return getRuleContexts(SingletonTagContext.class); 8354 } 8355 public HeadTagOpenContext headTagOpen(int i) { 8356 return getRuleContext(HeadTagOpenContext.class,i); 8357 } 8358 public TrTagOpenContext trTagOpen(int i) { 8359 return getRuleContext(TrTagOpenContext.class,i); 8360 } 8361 public JavadocInlineTagContext javadocInlineTag(int i) { 8362 return getRuleContext(JavadocInlineTagContext.class,i); 8363 } 8364 public List<ThContext> th() { 8365 return getRuleContexts(ThContext.class); 8366 } 8367 public DtContext dt(int i) { 8368 return getRuleContext(DtContext.class,i); 8369 } 8370 public PTagOpenContext pTagOpen(int i) { 8371 return getRuleContext(PTagOpenContext.class,i); 8372 } 8373 public TerminalNode LEADING_ASTERISK(int i) { 8374 return getToken(JavadocParser.LEADING_ASTERISK, i); 8375 } 8376 public List<TrTagOpenContext> trTagOpen() { 8377 return getRuleContexts(TrTagOpenContext.class); 8378 } 8379 public List<TbodyContext> tbody() { 8380 return getRuleContexts(TbodyContext.class); 8381 } 8382 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8383 public List<TheadTagOpenContext> theadTagOpen() { 8384 return getRuleContexts(TheadTagOpenContext.class); 8385 } 8386 public List<HeadContext> head() { 8387 return getRuleContexts(HeadContext.class); 8388 } 8389 public TerminalNode NEWLINE(int i) { 8390 return getToken(JavadocParser.NEWLINE, i); 8391 } 8392 public TextContext text(int i) { 8393 return getRuleContext(TextContext.class,i); 8394 } 8395 public List<BodyContext> body() { 8396 return getRuleContexts(BodyContext.class); 8397 } 8398 public List<OptionTagOpenContext> optionTagOpen() { 8399 return getRuleContexts(OptionTagOpenContext.class); 8400 } 8401 public List<TextContext> text() { 8402 return getRuleContexts(TextContext.class); 8403 } 8404 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8405 public TbodyTagOpenContext tbodyTagOpen(int i) { 8406 return getRuleContext(TbodyTagOpenContext.class,i); 8407 } 8408 public List<DdContext> dd() { 8409 return getRuleContexts(DdContext.class); 8410 } 8411 public TheadTagOpenContext theadTagOpen(int i) { 8412 return getRuleContext(TheadTagOpenContext.class,i); 8413 } 8414 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8415 return getRuleContext(ColgroupTagOpenContext.class,i); 8416 } 8417 public List<LiTagOpenContext> liTagOpen() { 8418 return getRuleContexts(LiTagOpenContext.class); 8419 } 8420 public DdContext dd(int i) { 8421 return getRuleContext(DdContext.class,i); 8422 } 8423 public List<OptionContext> option() { 8424 return getRuleContexts(OptionContext.class); 8425 } 8426 public TheadContext thead(int i) { 8427 return getRuleContext(TheadContext.class,i); 8428 } 8429 public BodyContext body(int i) { 8430 return getRuleContext(BodyContext.class,i); 8431 } 8432 public ThContext th(int i) { 8433 return getRuleContext(ThContext.class,i); 8434 } 8435 public List<PTagOpenContext> pTagOpen() { 8436 return getRuleContexts(PTagOpenContext.class); 8437 } 8438 public SingletonTagContext singletonTag(int i) { 8439 return getRuleContext(SingletonTagContext.class,i); 8440 } 8441 public TfootContext tfoot(int i) { 8442 return getRuleContext(TfootContext.class,i); 8443 } 8444 public HtmlContext(ParserRuleContext parent, int invokingState) { 8445 super(parent, invokingState); 8446 } 8447 @Override public int getRuleIndex() { return RULE_html; } 8448 @Override 8449 public void enterRule(ParseTreeListener listener) { 8450 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8451 } 8452 @Override 8453 public void exitRule(ParseTreeListener listener) { 8454 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8455 } 8456 @Override 8457 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8458 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8459 else return visitor.visitChildren(this); 8460 } 8461 } 8462 8463 public final HtmlContext html() throws RecognitionException { 8464 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8465 enterRule(_localctx, 76, RULE_html); 8466 try { 8467 int _alt; 8468 enterOuterAlt(_localctx, 1); 8469 { 8470 setState(1020); htmlTagOpen(); 8471 setState(1060); 8472 _errHandler.sync(this); 8473 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8474 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8475 if ( _alt==1 ) { 8476 { 8477 setState(1058); 8478 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8479 case 1: 8480 { 8481 setState(1021); htmlTag(); 8482 } 8483 break; 8484 8485 case 2: 8486 { 8487 setState(1022); singletonTag(); 8488 } 8489 break; 8490 8491 case 3: 8492 { 8493 setState(1023); paragraph(); 8494 } 8495 break; 8496 8497 case 4: 8498 { 8499 setState(1024); li(); 8500 } 8501 break; 8502 8503 case 5: 8504 { 8505 setState(1025); tr(); 8506 } 8507 break; 8508 8509 case 6: 8510 { 8511 setState(1026); td(); 8512 } 8513 break; 8514 8515 case 7: 8516 { 8517 setState(1027); th(); 8518 } 8519 break; 8520 8521 case 8: 8522 { 8523 setState(1028); body(); 8524 } 8525 break; 8526 8527 case 9: 8528 { 8529 setState(1029); colgroup(); 8530 } 8531 break; 8532 8533 case 10: 8534 { 8535 setState(1030); dd(); 8536 } 8537 break; 8538 8539 case 11: 8540 { 8541 setState(1031); dt(); 8542 } 8543 break; 8544 8545 case 12: 8546 { 8547 setState(1032); head(); 8548 } 8549 break; 8550 8551 case 13: 8552 { 8553 setState(1033); option(); 8554 } 8555 break; 8556 8557 case 14: 8558 { 8559 setState(1034); tbody(); 8560 } 8561 break; 8562 8563 case 15: 8564 { 8565 setState(1035); thead(); 8566 } 8567 break; 8568 8569 case 16: 8570 { 8571 setState(1036); tfoot(); 8572 } 8573 break; 8574 8575 case 17: 8576 { 8577 setState(1037); pTagOpen(); 8578 } 8579 break; 8580 8581 case 18: 8582 { 8583 setState(1038); liTagOpen(); 8584 } 8585 break; 8586 8587 case 19: 8588 { 8589 setState(1039); trTagOpen(); 8590 } 8591 break; 8592 8593 case 20: 8594 { 8595 setState(1040); tdTagOpen(); 8596 } 8597 break; 8598 8599 case 21: 8600 { 8601 setState(1041); thTagOpen(); 8602 } 8603 break; 8604 8605 case 22: 8606 { 8607 setState(1042); bodyTagOpen(); 8608 } 8609 break; 8610 8611 case 23: 8612 { 8613 setState(1043); colgroupTagOpen(); 8614 } 8615 break; 8616 8617 case 24: 8618 { 8619 setState(1044); ddTagOpen(); 8620 } 8621 break; 8622 8623 case 25: 8624 { 8625 setState(1045); dtTagOpen(); 8626 } 8627 break; 8628 8629 case 26: 8630 { 8631 setState(1046); headTagOpen(); 8632 } 8633 break; 8634 8635 case 27: 8636 { 8637 setState(1047); optionTagOpen(); 8638 } 8639 break; 8640 8641 case 28: 8642 { 8643 setState(1048); tbodyTagOpen(); 8644 } 8645 break; 8646 8647 case 29: 8648 { 8649 setState(1049); theadTagOpen(); 8650 } 8651 break; 8652 8653 case 30: 8654 { 8655 setState(1050); tfootTagOpen(); 8656 } 8657 break; 8658 8659 case 31: 8660 { 8661 { 8662 setState(1051); 8663 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8664 setState(1052); match(LEADING_ASTERISK); 8665 } 8666 } 8667 break; 8668 8669 case 32: 8670 { 8671 setState(1053); htmlComment(); 8672 } 8673 break; 8674 8675 case 33: 8676 { 8677 setState(1054); match(CDATA); 8678 } 8679 break; 8680 8681 case 34: 8682 { 8683 setState(1055); match(NEWLINE); 8684 } 8685 break; 8686 8687 case 35: 8688 { 8689 setState(1056); text(); 8690 } 8691 break; 8692 8693 case 36: 8694 { 8695 setState(1057); javadocInlineTag(); 8696 } 8697 break; 8698 } 8699 } 8700 } 8701 setState(1062); 8702 _errHandler.sync(this); 8703 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8704 } 8705 setState(1063); htmlTagClose(); 8706 } 8707 } 8708 catch (RecognitionException re) { 8709 _localctx.exception = re; 8710 _errHandler.reportError(this, re); 8711 _errHandler.recover(this, re); 8712 } 8713 finally { 8714 exitRule(); 8715 } 8716 return _localctx; 8717 } 8718 8719 public static class OptionTagOpenContext extends ParserRuleContext { 8720 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8721 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8722 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8723 public TerminalNode NEWLINE(int i) { 8724 return getToken(JavadocParser.NEWLINE, i); 8725 } 8726 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8727 public List<AttributeContext> attribute() { 8728 return getRuleContexts(AttributeContext.class); 8729 } 8730 public AttributeContext attribute(int i) { 8731 return getRuleContext(AttributeContext.class,i); 8732 } 8733 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8734 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8735 public TerminalNode LEADING_ASTERISK(int i) { 8736 return getToken(JavadocParser.LEADING_ASTERISK, i); 8737 } 8738 public TerminalNode WS(int i) { 8739 return getToken(JavadocParser.WS, i); 8740 } 8741 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 8742 super(parent, invokingState); 8743 } 8744 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 8745 @Override 8746 public void enterRule(ParseTreeListener listener) { 8747 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 8748 } 8749 @Override 8750 public void exitRule(ParseTreeListener listener) { 8751 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 8752 } 8753 @Override 8754 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8755 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 8756 else return visitor.visitChildren(this); 8757 } 8758 } 8759 8760 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 8761 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 8762 enterRule(_localctx, 78, RULE_optionTagOpen); 8763 int _la; 8764 try { 8765 enterOuterAlt(_localctx, 1); 8766 { 8767 setState(1065); match(OPEN); 8768 setState(1066); match(OPTION_HTML_TAG_NAME); 8769 setState(1073); 8770 _errHandler.sync(this); 8771 _la = _input.LA(1); 8772 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8773 { 8774 setState(1071); 8775 switch (_input.LA(1)) { 8776 case HTML_TAG_NAME: 8777 { 8778 setState(1067); attribute(); 8779 } 8780 break; 8781 case NEWLINE: 8782 { 8783 setState(1068); match(NEWLINE); 8784 } 8785 break; 8786 case LEADING_ASTERISK: 8787 { 8788 setState(1069); match(LEADING_ASTERISK); 8789 } 8790 break; 8791 case WS: 8792 { 8793 setState(1070); match(WS); 8794 } 8795 break; 8796 default: 8797 throw new NoViableAltException(this); 8798 } 8799 } 8800 setState(1075); 8801 _errHandler.sync(this); 8802 _la = _input.LA(1); 8803 } 8804 setState(1076); match(CLOSE); 8805 } 8806 } 8807 catch (RecognitionException re) { 8808 _localctx.exception = re; 8809 _errHandler.reportError(this, re); 8810 _errHandler.recover(this, re); 8811 } 8812 finally { 8813 exitRule(); 8814 } 8815 return _localctx; 8816 } 8817 8818 public static class OptionTagCloseContext extends ParserRuleContext { 8819 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8820 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8821 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8822 public TerminalNode NEWLINE(int i) { 8823 return getToken(JavadocParser.NEWLINE, i); 8824 } 8825 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8826 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8827 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8828 public TerminalNode LEADING_ASTERISK(int i) { 8829 return getToken(JavadocParser.LEADING_ASTERISK, i); 8830 } 8831 public TerminalNode WS(int i) { 8832 return getToken(JavadocParser.WS, i); 8833 } 8834 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8835 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 8836 super(parent, invokingState); 8837 } 8838 @Override public int getRuleIndex() { return RULE_optionTagClose; } 8839 @Override 8840 public void enterRule(ParseTreeListener listener) { 8841 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 8842 } 8843 @Override 8844 public void exitRule(ParseTreeListener listener) { 8845 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 8846 } 8847 @Override 8848 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8849 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 8850 else return visitor.visitChildren(this); 8851 } 8852 } 8853 8854 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 8855 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 8856 enterRule(_localctx, 80, RULE_optionTagClose); 8857 int _la; 8858 try { 8859 enterOuterAlt(_localctx, 1); 8860 { 8861 setState(1078); match(OPEN); 8862 setState(1079); match(SLASH); 8863 setState(1080); match(OPTION_HTML_TAG_NAME); 8864 setState(1084); 8865 _errHandler.sync(this); 8866 _la = _input.LA(1); 8867 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8868 { 8869 { 8870 setState(1081); 8871 _la = _input.LA(1); 8872 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8873 _errHandler.recoverInline(this); 8874 } 8875 consume(); 8876 } 8877 } 8878 setState(1086); 8879 _errHandler.sync(this); 8880 _la = _input.LA(1); 8881 } 8882 setState(1087); match(CLOSE); 8883 } 8884 } 8885 catch (RecognitionException re) { 8886 _localctx.exception = re; 8887 _errHandler.reportError(this, re); 8888 _errHandler.recover(this, re); 8889 } 8890 finally { 8891 exitRule(); 8892 } 8893 return _localctx; 8894 } 8895 8896 public static class OptionContext extends ParserRuleContext { 8897 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8898 return getRuleContexts(ColgroupTagOpenContext.class); 8899 } 8900 public TbodyContext tbody(int i) { 8901 return getRuleContext(TbodyContext.class,i); 8902 } 8903 public TerminalNode CDATA(int i) { 8904 return getToken(JavadocParser.CDATA, i); 8905 } 8906 public TfootTagOpenContext tfootTagOpen(int i) { 8907 return getRuleContext(TfootTagOpenContext.class,i); 8908 } 8909 public List<DtTagOpenContext> dtTagOpen() { 8910 return getRuleContexts(DtTagOpenContext.class); 8911 } 8912 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8913 public List<ColgroupContext> colgroup() { 8914 return getRuleContexts(ColgroupContext.class); 8915 } 8916 public HeadContext head(int i) { 8917 return getRuleContext(HeadContext.class,i); 8918 } 8919 public List<TrContext> tr() { 8920 return getRuleContexts(TrContext.class); 8921 } 8922 public List<LiContext> li() { 8923 return getRuleContexts(LiContext.class); 8924 } 8925 public ThTagOpenContext thTagOpen(int i) { 8926 return getRuleContext(ThTagOpenContext.class,i); 8927 } 8928 public List<DdTagOpenContext> ddTagOpen() { 8929 return getRuleContexts(DdTagOpenContext.class); 8930 } 8931 public ColgroupContext colgroup(int i) { 8932 return getRuleContext(ColgroupContext.class,i); 8933 } 8934 public TdTagOpenContext tdTagOpen(int i) { 8935 return getRuleContext(TdTagOpenContext.class,i); 8936 } 8937 public List<ThTagOpenContext> thTagOpen() { 8938 return getRuleContexts(ThTagOpenContext.class); 8939 } 8940 public List<HeadTagOpenContext> headTagOpen() { 8941 return getRuleContexts(HeadTagOpenContext.class); 8942 } 8943 public List<HtmlTagOpenContext> htmlTagOpen() { 8944 return getRuleContexts(HtmlTagOpenContext.class); 8945 } 8946 public List<TbodyTagOpenContext> tbodyTagOpen() { 8947 return getRuleContexts(TbodyTagOpenContext.class); 8948 } 8949 public List<TheadContext> thead() { 8950 return getRuleContexts(TheadContext.class); 8951 } 8952 public LiContext li(int i) { 8953 return getRuleContext(LiContext.class,i); 8954 } 8955 public List<TfootTagOpenContext> tfootTagOpen() { 8956 return getRuleContexts(TfootTagOpenContext.class); 8957 } 8958 public List<TfootContext> tfoot() { 8959 return getRuleContexts(TfootContext.class); 8960 } 8961 public List<JavadocInlineTagContext> javadocInlineTag() { 8962 return getRuleContexts(JavadocInlineTagContext.class); 8963 } 8964 public List<HtmlCommentContext> htmlComment() { 8965 return getRuleContexts(HtmlCommentContext.class); 8966 } 8967 public TrContext tr(int i) { 8968 return getRuleContext(TrContext.class,i); 8969 } 8970 public List<DtContext> dt() { 8971 return getRuleContexts(DtContext.class); 8972 } 8973 public HtmlCommentContext htmlComment(int i) { 8974 return getRuleContext(HtmlCommentContext.class,i); 8975 } 8976 public List<TdContext> td() { 8977 return getRuleContexts(TdContext.class); 8978 } 8979 public List<BodyTagOpenContext> bodyTagOpen() { 8980 return getRuleContexts(BodyTagOpenContext.class); 8981 } 8982 public DtTagOpenContext dtTagOpen(int i) { 8983 return getRuleContext(DtTagOpenContext.class,i); 8984 } 8985 public HtmlContext html(int i) { 8986 return getRuleContext(HtmlContext.class,i); 8987 } 8988 public BodyTagOpenContext bodyTagOpen(int i) { 8989 return getRuleContext(BodyTagOpenContext.class,i); 8990 } 8991 public DdTagOpenContext ddTagOpen(int i) { 8992 return getRuleContext(DdTagOpenContext.class,i); 8993 } 8994 public OptionTagCloseContext optionTagClose() { 8995 return getRuleContext(OptionTagCloseContext.class,0); 8996 } 8997 public List<HtmlTagContext> htmlTag() { 8998 return getRuleContexts(HtmlTagContext.class); 8999 } 9000 public ParagraphContext paragraph(int i) { 9001 return getRuleContext(ParagraphContext.class,i); 9002 } 9003 public List<TdTagOpenContext> tdTagOpen() { 9004 return getRuleContexts(TdTagOpenContext.class); 9005 } 9006 public LiTagOpenContext liTagOpen(int i) { 9007 return getRuleContext(LiTagOpenContext.class,i); 9008 } 9009 public TdContext td(int i) { 9010 return getRuleContext(TdContext.class,i); 9011 } 9012 public List<ParagraphContext> paragraph() { 9013 return getRuleContexts(ParagraphContext.class); 9014 } 9015 public HtmlTagContext htmlTag(int i) { 9016 return getRuleContext(HtmlTagContext.class,i); 9017 } 9018 public List<SingletonTagContext> singletonTag() { 9019 return getRuleContexts(SingletonTagContext.class); 9020 } 9021 public HeadTagOpenContext headTagOpen(int i) { 9022 return getRuleContext(HeadTagOpenContext.class,i); 9023 } 9024 public TrTagOpenContext trTagOpen(int i) { 9025 return getRuleContext(TrTagOpenContext.class,i); 9026 } 9027 public List<HtmlContext> html() { 9028 return getRuleContexts(HtmlContext.class); 9029 } 9030 public JavadocInlineTagContext javadocInlineTag(int i) { 9031 return getRuleContext(JavadocInlineTagContext.class,i); 9032 } 9033 public List<ThContext> th() { 9034 return getRuleContexts(ThContext.class); 9035 } 9036 public DtContext dt(int i) { 9037 return getRuleContext(DtContext.class,i); 9038 } 9039 public PTagOpenContext pTagOpen(int i) { 9040 return getRuleContext(PTagOpenContext.class,i); 9041 } 9042 public TerminalNode LEADING_ASTERISK(int i) { 9043 return getToken(JavadocParser.LEADING_ASTERISK, i); 9044 } 9045 public List<TrTagOpenContext> trTagOpen() { 9046 return getRuleContexts(TrTagOpenContext.class); 9047 } 9048 public List<TbodyContext> tbody() { 9049 return getRuleContexts(TbodyContext.class); 9050 } 9051 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9052 public List<TheadTagOpenContext> theadTagOpen() { 9053 return getRuleContexts(TheadTagOpenContext.class); 9054 } 9055 public List<HeadContext> head() { 9056 return getRuleContexts(HeadContext.class); 9057 } 9058 public TerminalNode NEWLINE(int i) { 9059 return getToken(JavadocParser.NEWLINE, i); 9060 } 9061 public TextContext text(int i) { 9062 return getRuleContext(TextContext.class,i); 9063 } 9064 public List<BodyContext> body() { 9065 return getRuleContexts(BodyContext.class); 9066 } 9067 public OptionTagOpenContext optionTagOpen() { 9068 return getRuleContext(OptionTagOpenContext.class,0); 9069 } 9070 public List<TextContext> text() { 9071 return getRuleContexts(TextContext.class); 9072 } 9073 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9074 public TbodyTagOpenContext tbodyTagOpen(int i) { 9075 return getRuleContext(TbodyTagOpenContext.class,i); 9076 } 9077 public List<DdContext> dd() { 9078 return getRuleContexts(DdContext.class); 9079 } 9080 public TheadTagOpenContext theadTagOpen(int i) { 9081 return getRuleContext(TheadTagOpenContext.class,i); 9082 } 9083 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9084 return getRuleContext(ColgroupTagOpenContext.class,i); 9085 } 9086 public List<LiTagOpenContext> liTagOpen() { 9087 return getRuleContexts(LiTagOpenContext.class); 9088 } 9089 public DdContext dd(int i) { 9090 return getRuleContext(DdContext.class,i); 9091 } 9092 public TheadContext thead(int i) { 9093 return getRuleContext(TheadContext.class,i); 9094 } 9095 public BodyContext body(int i) { 9096 return getRuleContext(BodyContext.class,i); 9097 } 9098 public ThContext th(int i) { 9099 return getRuleContext(ThContext.class,i); 9100 } 9101 public List<PTagOpenContext> pTagOpen() { 9102 return getRuleContexts(PTagOpenContext.class); 9103 } 9104 public HtmlTagOpenContext htmlTagOpen(int i) { 9105 return getRuleContext(HtmlTagOpenContext.class,i); 9106 } 9107 public SingletonTagContext singletonTag(int i) { 9108 return getRuleContext(SingletonTagContext.class,i); 9109 } 9110 public TfootContext tfoot(int i) { 9111 return getRuleContext(TfootContext.class,i); 9112 } 9113 public OptionContext(ParserRuleContext parent, int invokingState) { 9114 super(parent, invokingState); 9115 } 9116 @Override public int getRuleIndex() { return RULE_option; } 9117 @Override 9118 public void enterRule(ParseTreeListener listener) { 9119 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9120 } 9121 @Override 9122 public void exitRule(ParseTreeListener listener) { 9123 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9124 } 9125 @Override 9126 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9127 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9128 else return visitor.visitChildren(this); 9129 } 9130 } 9131 9132 public final OptionContext option() throws RecognitionException { 9133 OptionContext _localctx = new OptionContext(_ctx, getState()); 9134 enterRule(_localctx, 82, RULE_option); 9135 try { 9136 int _alt; 9137 enterOuterAlt(_localctx, 1); 9138 { 9139 setState(1089); optionTagOpen(); 9140 setState(1129); 9141 _errHandler.sync(this); 9142 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9143 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9144 if ( _alt==1 ) { 9145 { 9146 setState(1127); 9147 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9148 case 1: 9149 { 9150 setState(1090); htmlTag(); 9151 } 9152 break; 9153 9154 case 2: 9155 { 9156 setState(1091); singletonTag(); 9157 } 9158 break; 9159 9160 case 3: 9161 { 9162 setState(1092); paragraph(); 9163 } 9164 break; 9165 9166 case 4: 9167 { 9168 setState(1093); li(); 9169 } 9170 break; 9171 9172 case 5: 9173 { 9174 setState(1094); tr(); 9175 } 9176 break; 9177 9178 case 6: 9179 { 9180 setState(1095); td(); 9181 } 9182 break; 9183 9184 case 7: 9185 { 9186 setState(1096); th(); 9187 } 9188 break; 9189 9190 case 8: 9191 { 9192 setState(1097); body(); 9193 } 9194 break; 9195 9196 case 9: 9197 { 9198 setState(1098); colgroup(); 9199 } 9200 break; 9201 9202 case 10: 9203 { 9204 setState(1099); dd(); 9205 } 9206 break; 9207 9208 case 11: 9209 { 9210 setState(1100); dt(); 9211 } 9212 break; 9213 9214 case 12: 9215 { 9216 setState(1101); head(); 9217 } 9218 break; 9219 9220 case 13: 9221 { 9222 setState(1102); html(); 9223 } 9224 break; 9225 9226 case 14: 9227 { 9228 setState(1103); tbody(); 9229 } 9230 break; 9231 9232 case 15: 9233 { 9234 setState(1104); thead(); 9235 } 9236 break; 9237 9238 case 16: 9239 { 9240 setState(1105); tfoot(); 9241 } 9242 break; 9243 9244 case 17: 9245 { 9246 setState(1106); pTagOpen(); 9247 } 9248 break; 9249 9250 case 18: 9251 { 9252 setState(1107); liTagOpen(); 9253 } 9254 break; 9255 9256 case 19: 9257 { 9258 setState(1108); trTagOpen(); 9259 } 9260 break; 9261 9262 case 20: 9263 { 9264 setState(1109); tdTagOpen(); 9265 } 9266 break; 9267 9268 case 21: 9269 { 9270 setState(1110); thTagOpen(); 9271 } 9272 break; 9273 9274 case 22: 9275 { 9276 setState(1111); bodyTagOpen(); 9277 } 9278 break; 9279 9280 case 23: 9281 { 9282 setState(1112); colgroupTagOpen(); 9283 } 9284 break; 9285 9286 case 24: 9287 { 9288 setState(1113); ddTagOpen(); 9289 } 9290 break; 9291 9292 case 25: 9293 { 9294 setState(1114); dtTagOpen(); 9295 } 9296 break; 9297 9298 case 26: 9299 { 9300 setState(1115); headTagOpen(); 9301 } 9302 break; 9303 9304 case 27: 9305 { 9306 setState(1116); htmlTagOpen(); 9307 } 9308 break; 9309 9310 case 28: 9311 { 9312 setState(1117); tbodyTagOpen(); 9313 } 9314 break; 9315 9316 case 29: 9317 { 9318 setState(1118); theadTagOpen(); 9319 } 9320 break; 9321 9322 case 30: 9323 { 9324 setState(1119); tfootTagOpen(); 9325 } 9326 break; 9327 9328 case 31: 9329 { 9330 { 9331 setState(1120); 9332 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9333 setState(1121); match(LEADING_ASTERISK); 9334 } 9335 } 9336 break; 9337 9338 case 32: 9339 { 9340 setState(1122); htmlComment(); 9341 } 9342 break; 9343 9344 case 33: 9345 { 9346 setState(1123); match(CDATA); 9347 } 9348 break; 9349 9350 case 34: 9351 { 9352 setState(1124); match(NEWLINE); 9353 } 9354 break; 9355 9356 case 35: 9357 { 9358 setState(1125); text(); 9359 } 9360 break; 9361 9362 case 36: 9363 { 9364 setState(1126); javadocInlineTag(); 9365 } 9366 break; 9367 } 9368 } 9369 } 9370 setState(1131); 9371 _errHandler.sync(this); 9372 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9373 } 9374 setState(1132); optionTagClose(); 9375 } 9376 } 9377 catch (RecognitionException re) { 9378 _localctx.exception = re; 9379 _errHandler.reportError(this, re); 9380 _errHandler.recover(this, re); 9381 } 9382 finally { 9383 exitRule(); 9384 } 9385 return _localctx; 9386 } 9387 9388 public static class TbodyTagOpenContext extends ParserRuleContext { 9389 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9390 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9391 public TerminalNode NEWLINE(int i) { 9392 return getToken(JavadocParser.NEWLINE, i); 9393 } 9394 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9395 public List<AttributeContext> attribute() { 9396 return getRuleContexts(AttributeContext.class); 9397 } 9398 public AttributeContext attribute(int i) { 9399 return getRuleContext(AttributeContext.class,i); 9400 } 9401 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9402 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9403 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9404 public TerminalNode LEADING_ASTERISK(int i) { 9405 return getToken(JavadocParser.LEADING_ASTERISK, i); 9406 } 9407 public TerminalNode WS(int i) { 9408 return getToken(JavadocParser.WS, i); 9409 } 9410 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9411 super(parent, invokingState); 9412 } 9413 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9414 @Override 9415 public void enterRule(ParseTreeListener listener) { 9416 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9417 } 9418 @Override 9419 public void exitRule(ParseTreeListener listener) { 9420 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9421 } 9422 @Override 9423 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9424 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9425 else return visitor.visitChildren(this); 9426 } 9427 } 9428 9429 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9430 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9431 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9432 int _la; 9433 try { 9434 enterOuterAlt(_localctx, 1); 9435 { 9436 setState(1134); match(OPEN); 9437 setState(1135); match(TBODY_HTML_TAG_NAME); 9438 setState(1142); 9439 _errHandler.sync(this); 9440 _la = _input.LA(1); 9441 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9442 { 9443 setState(1140); 9444 switch (_input.LA(1)) { 9445 case HTML_TAG_NAME: 9446 { 9447 setState(1136); attribute(); 9448 } 9449 break; 9450 case NEWLINE: 9451 { 9452 setState(1137); match(NEWLINE); 9453 } 9454 break; 9455 case LEADING_ASTERISK: 9456 { 9457 setState(1138); match(LEADING_ASTERISK); 9458 } 9459 break; 9460 case WS: 9461 { 9462 setState(1139); match(WS); 9463 } 9464 break; 9465 default: 9466 throw new NoViableAltException(this); 9467 } 9468 } 9469 setState(1144); 9470 _errHandler.sync(this); 9471 _la = _input.LA(1); 9472 } 9473 setState(1145); match(CLOSE); 9474 } 9475 } 9476 catch (RecognitionException re) { 9477 _localctx.exception = re; 9478 _errHandler.reportError(this, re); 9479 _errHandler.recover(this, re); 9480 } 9481 finally { 9482 exitRule(); 9483 } 9484 return _localctx; 9485 } 9486 9487 public static class TbodyTagCloseContext extends ParserRuleContext { 9488 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9489 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9490 public TerminalNode NEWLINE(int i) { 9491 return getToken(JavadocParser.NEWLINE, i); 9492 } 9493 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9494 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9495 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9496 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9497 public TerminalNode LEADING_ASTERISK(int i) { 9498 return getToken(JavadocParser.LEADING_ASTERISK, i); 9499 } 9500 public TerminalNode WS(int i) { 9501 return getToken(JavadocParser.WS, i); 9502 } 9503 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9504 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9505 super(parent, invokingState); 9506 } 9507 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9508 @Override 9509 public void enterRule(ParseTreeListener listener) { 9510 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9511 } 9512 @Override 9513 public void exitRule(ParseTreeListener listener) { 9514 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9515 } 9516 @Override 9517 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9518 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9519 else return visitor.visitChildren(this); 9520 } 9521 } 9522 9523 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9524 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9525 enterRule(_localctx, 86, RULE_tbodyTagClose); 9526 int _la; 9527 try { 9528 enterOuterAlt(_localctx, 1); 9529 { 9530 setState(1147); match(OPEN); 9531 setState(1148); match(SLASH); 9532 setState(1149); match(TBODY_HTML_TAG_NAME); 9533 setState(1153); 9534 _errHandler.sync(this); 9535 _la = _input.LA(1); 9536 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9537 { 9538 { 9539 setState(1150); 9540 _la = _input.LA(1); 9541 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9542 _errHandler.recoverInline(this); 9543 } 9544 consume(); 9545 } 9546 } 9547 setState(1155); 9548 _errHandler.sync(this); 9549 _la = _input.LA(1); 9550 } 9551 setState(1156); match(CLOSE); 9552 } 9553 } 9554 catch (RecognitionException re) { 9555 _localctx.exception = re; 9556 _errHandler.reportError(this, re); 9557 _errHandler.recover(this, re); 9558 } 9559 finally { 9560 exitRule(); 9561 } 9562 return _localctx; 9563 } 9564 9565 public static class TbodyContext extends ParserRuleContext { 9566 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9567 return getRuleContexts(ColgroupTagOpenContext.class); 9568 } 9569 public TbodyTagCloseContext tbodyTagClose() { 9570 return getRuleContext(TbodyTagCloseContext.class,0); 9571 } 9572 public TerminalNode CDATA(int i) { 9573 return getToken(JavadocParser.CDATA, i); 9574 } 9575 public TfootTagOpenContext tfootTagOpen(int i) { 9576 return getRuleContext(TfootTagOpenContext.class,i); 9577 } 9578 public List<DtTagOpenContext> dtTagOpen() { 9579 return getRuleContexts(DtTagOpenContext.class); 9580 } 9581 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9582 public List<ColgroupContext> colgroup() { 9583 return getRuleContexts(ColgroupContext.class); 9584 } 9585 public HeadContext head(int i) { 9586 return getRuleContext(HeadContext.class,i); 9587 } 9588 public List<TrContext> tr() { 9589 return getRuleContexts(TrContext.class); 9590 } 9591 public List<LiContext> li() { 9592 return getRuleContexts(LiContext.class); 9593 } 9594 public ThTagOpenContext thTagOpen(int i) { 9595 return getRuleContext(ThTagOpenContext.class,i); 9596 } 9597 public List<DdTagOpenContext> ddTagOpen() { 9598 return getRuleContexts(DdTagOpenContext.class); 9599 } 9600 public ColgroupContext colgroup(int i) { 9601 return getRuleContext(ColgroupContext.class,i); 9602 } 9603 public TdTagOpenContext tdTagOpen(int i) { 9604 return getRuleContext(TdTagOpenContext.class,i); 9605 } 9606 public List<ThTagOpenContext> thTagOpen() { 9607 return getRuleContexts(ThTagOpenContext.class); 9608 } 9609 public List<HeadTagOpenContext> headTagOpen() { 9610 return getRuleContexts(HeadTagOpenContext.class); 9611 } 9612 public List<HtmlTagOpenContext> htmlTagOpen() { 9613 return getRuleContexts(HtmlTagOpenContext.class); 9614 } 9615 public TbodyTagOpenContext tbodyTagOpen() { 9616 return getRuleContext(TbodyTagOpenContext.class,0); 9617 } 9618 public List<TheadContext> thead() { 9619 return getRuleContexts(TheadContext.class); 9620 } 9621 public LiContext li(int i) { 9622 return getRuleContext(LiContext.class,i); 9623 } 9624 public List<TfootTagOpenContext> tfootTagOpen() { 9625 return getRuleContexts(TfootTagOpenContext.class); 9626 } 9627 public List<TfootContext> tfoot() { 9628 return getRuleContexts(TfootContext.class); 9629 } 9630 public List<JavadocInlineTagContext> javadocInlineTag() { 9631 return getRuleContexts(JavadocInlineTagContext.class); 9632 } 9633 public List<HtmlCommentContext> htmlComment() { 9634 return getRuleContexts(HtmlCommentContext.class); 9635 } 9636 public OptionContext option(int i) { 9637 return getRuleContext(OptionContext.class,i); 9638 } 9639 public TrContext tr(int i) { 9640 return getRuleContext(TrContext.class,i); 9641 } 9642 public List<DtContext> dt() { 9643 return getRuleContexts(DtContext.class); 9644 } 9645 public HtmlCommentContext htmlComment(int i) { 9646 return getRuleContext(HtmlCommentContext.class,i); 9647 } 9648 public List<TdContext> td() { 9649 return getRuleContexts(TdContext.class); 9650 } 9651 public List<BodyTagOpenContext> bodyTagOpen() { 9652 return getRuleContexts(BodyTagOpenContext.class); 9653 } 9654 public DtTagOpenContext dtTagOpen(int i) { 9655 return getRuleContext(DtTagOpenContext.class,i); 9656 } 9657 public HtmlContext html(int i) { 9658 return getRuleContext(HtmlContext.class,i); 9659 } 9660 public BodyTagOpenContext bodyTagOpen(int i) { 9661 return getRuleContext(BodyTagOpenContext.class,i); 9662 } 9663 public DdTagOpenContext ddTagOpen(int i) { 9664 return getRuleContext(DdTagOpenContext.class,i); 9665 } 9666 public List<HtmlTagContext> htmlTag() { 9667 return getRuleContexts(HtmlTagContext.class); 9668 } 9669 public ParagraphContext paragraph(int i) { 9670 return getRuleContext(ParagraphContext.class,i); 9671 } 9672 public List<TdTagOpenContext> tdTagOpen() { 9673 return getRuleContexts(TdTagOpenContext.class); 9674 } 9675 public OptionTagOpenContext optionTagOpen(int i) { 9676 return getRuleContext(OptionTagOpenContext.class,i); 9677 } 9678 public LiTagOpenContext liTagOpen(int i) { 9679 return getRuleContext(LiTagOpenContext.class,i); 9680 } 9681 public TdContext td(int i) { 9682 return getRuleContext(TdContext.class,i); 9683 } 9684 public List<ParagraphContext> paragraph() { 9685 return getRuleContexts(ParagraphContext.class); 9686 } 9687 public HtmlTagContext htmlTag(int i) { 9688 return getRuleContext(HtmlTagContext.class,i); 9689 } 9690 public List<SingletonTagContext> singletonTag() { 9691 return getRuleContexts(SingletonTagContext.class); 9692 } 9693 public HeadTagOpenContext headTagOpen(int i) { 9694 return getRuleContext(HeadTagOpenContext.class,i); 9695 } 9696 public TrTagOpenContext trTagOpen(int i) { 9697 return getRuleContext(TrTagOpenContext.class,i); 9698 } 9699 public List<HtmlContext> html() { 9700 return getRuleContexts(HtmlContext.class); 9701 } 9702 public JavadocInlineTagContext javadocInlineTag(int i) { 9703 return getRuleContext(JavadocInlineTagContext.class,i); 9704 } 9705 public List<ThContext> th() { 9706 return getRuleContexts(ThContext.class); 9707 } 9708 public DtContext dt(int i) { 9709 return getRuleContext(DtContext.class,i); 9710 } 9711 public PTagOpenContext pTagOpen(int i) { 9712 return getRuleContext(PTagOpenContext.class,i); 9713 } 9714 public TerminalNode LEADING_ASTERISK(int i) { 9715 return getToken(JavadocParser.LEADING_ASTERISK, i); 9716 } 9717 public List<TrTagOpenContext> trTagOpen() { 9718 return getRuleContexts(TrTagOpenContext.class); 9719 } 9720 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9721 public List<TheadTagOpenContext> theadTagOpen() { 9722 return getRuleContexts(TheadTagOpenContext.class); 9723 } 9724 public List<HeadContext> head() { 9725 return getRuleContexts(HeadContext.class); 9726 } 9727 public TerminalNode NEWLINE(int i) { 9728 return getToken(JavadocParser.NEWLINE, i); 9729 } 9730 public TextContext text(int i) { 9731 return getRuleContext(TextContext.class,i); 9732 } 9733 public List<BodyContext> body() { 9734 return getRuleContexts(BodyContext.class); 9735 } 9736 public List<OptionTagOpenContext> optionTagOpen() { 9737 return getRuleContexts(OptionTagOpenContext.class); 9738 } 9739 public List<TextContext> text() { 9740 return getRuleContexts(TextContext.class); 9741 } 9742 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9743 public List<DdContext> dd() { 9744 return getRuleContexts(DdContext.class); 9745 } 9746 public TheadTagOpenContext theadTagOpen(int i) { 9747 return getRuleContext(TheadTagOpenContext.class,i); 9748 } 9749 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9750 return getRuleContext(ColgroupTagOpenContext.class,i); 9751 } 9752 public List<LiTagOpenContext> liTagOpen() { 9753 return getRuleContexts(LiTagOpenContext.class); 9754 } 9755 public DdContext dd(int i) { 9756 return getRuleContext(DdContext.class,i); 9757 } 9758 public List<OptionContext> option() { 9759 return getRuleContexts(OptionContext.class); 9760 } 9761 public TheadContext thead(int i) { 9762 return getRuleContext(TheadContext.class,i); 9763 } 9764 public BodyContext body(int i) { 9765 return getRuleContext(BodyContext.class,i); 9766 } 9767 public ThContext th(int i) { 9768 return getRuleContext(ThContext.class,i); 9769 } 9770 public List<PTagOpenContext> pTagOpen() { 9771 return getRuleContexts(PTagOpenContext.class); 9772 } 9773 public HtmlTagOpenContext htmlTagOpen(int i) { 9774 return getRuleContext(HtmlTagOpenContext.class,i); 9775 } 9776 public SingletonTagContext singletonTag(int i) { 9777 return getRuleContext(SingletonTagContext.class,i); 9778 } 9779 public TfootContext tfoot(int i) { 9780 return getRuleContext(TfootContext.class,i); 9781 } 9782 public TbodyContext(ParserRuleContext parent, int invokingState) { 9783 super(parent, invokingState); 9784 } 9785 @Override public int getRuleIndex() { return RULE_tbody; } 9786 @Override 9787 public void enterRule(ParseTreeListener listener) { 9788 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 9789 } 9790 @Override 9791 public void exitRule(ParseTreeListener listener) { 9792 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 9793 } 9794 @Override 9795 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9796 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 9797 else return visitor.visitChildren(this); 9798 } 9799 } 9800 9801 public final TbodyContext tbody() throws RecognitionException { 9802 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 9803 enterRule(_localctx, 88, RULE_tbody); 9804 try { 9805 int _alt; 9806 enterOuterAlt(_localctx, 1); 9807 { 9808 setState(1158); tbodyTagOpen(); 9809 setState(1198); 9810 _errHandler.sync(this); 9811 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 9812 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9813 if ( _alt==1 ) { 9814 { 9815 setState(1196); 9816 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 9817 case 1: 9818 { 9819 setState(1159); htmlTag(); 9820 } 9821 break; 9822 9823 case 2: 9824 { 9825 setState(1160); singletonTag(); 9826 } 9827 break; 9828 9829 case 3: 9830 { 9831 setState(1161); paragraph(); 9832 } 9833 break; 9834 9835 case 4: 9836 { 9837 setState(1162); li(); 9838 } 9839 break; 9840 9841 case 5: 9842 { 9843 setState(1163); tr(); 9844 } 9845 break; 9846 9847 case 6: 9848 { 9849 setState(1164); td(); 9850 } 9851 break; 9852 9853 case 7: 9854 { 9855 setState(1165); th(); 9856 } 9857 break; 9858 9859 case 8: 9860 { 9861 setState(1166); body(); 9862 } 9863 break; 9864 9865 case 9: 9866 { 9867 setState(1167); colgroup(); 9868 } 9869 break; 9870 9871 case 10: 9872 { 9873 setState(1168); dd(); 9874 } 9875 break; 9876 9877 case 11: 9878 { 9879 setState(1169); dt(); 9880 } 9881 break; 9882 9883 case 12: 9884 { 9885 setState(1170); head(); 9886 } 9887 break; 9888 9889 case 13: 9890 { 9891 setState(1171); html(); 9892 } 9893 break; 9894 9895 case 14: 9896 { 9897 setState(1172); option(); 9898 } 9899 break; 9900 9901 case 15: 9902 { 9903 setState(1173); thead(); 9904 } 9905 break; 9906 9907 case 16: 9908 { 9909 setState(1174); tfoot(); 9910 } 9911 break; 9912 9913 case 17: 9914 { 9915 setState(1175); pTagOpen(); 9916 } 9917 break; 9918 9919 case 18: 9920 { 9921 setState(1176); liTagOpen(); 9922 } 9923 break; 9924 9925 case 19: 9926 { 9927 setState(1177); trTagOpen(); 9928 } 9929 break; 9930 9931 case 20: 9932 { 9933 setState(1178); tdTagOpen(); 9934 } 9935 break; 9936 9937 case 21: 9938 { 9939 setState(1179); thTagOpen(); 9940 } 9941 break; 9942 9943 case 22: 9944 { 9945 setState(1180); bodyTagOpen(); 9946 } 9947 break; 9948 9949 case 23: 9950 { 9951 setState(1181); colgroupTagOpen(); 9952 } 9953 break; 9954 9955 case 24: 9956 { 9957 setState(1182); ddTagOpen(); 9958 } 9959 break; 9960 9961 case 25: 9962 { 9963 setState(1183); dtTagOpen(); 9964 } 9965 break; 9966 9967 case 26: 9968 { 9969 setState(1184); headTagOpen(); 9970 } 9971 break; 9972 9973 case 27: 9974 { 9975 setState(1185); htmlTagOpen(); 9976 } 9977 break; 9978 9979 case 28: 9980 { 9981 setState(1186); optionTagOpen(); 9982 } 9983 break; 9984 9985 case 29: 9986 { 9987 setState(1187); theadTagOpen(); 9988 } 9989 break; 9990 9991 case 30: 9992 { 9993 setState(1188); tfootTagOpen(); 9994 } 9995 break; 9996 9997 case 31: 9998 { 9999 { 10000 setState(1189); 10001 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10002 setState(1190); match(LEADING_ASTERISK); 10003 } 10004 } 10005 break; 10006 10007 case 32: 10008 { 10009 setState(1191); htmlComment(); 10010 } 10011 break; 10012 10013 case 33: 10014 { 10015 setState(1192); match(CDATA); 10016 } 10017 break; 10018 10019 case 34: 10020 { 10021 setState(1193); match(NEWLINE); 10022 } 10023 break; 10024 10025 case 35: 10026 { 10027 setState(1194); text(); 10028 } 10029 break; 10030 10031 case 36: 10032 { 10033 setState(1195); javadocInlineTag(); 10034 } 10035 break; 10036 } 10037 } 10038 } 10039 setState(1200); 10040 _errHandler.sync(this); 10041 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10042 } 10043 setState(1201); tbodyTagClose(); 10044 } 10045 } 10046 catch (RecognitionException re) { 10047 _localctx.exception = re; 10048 _errHandler.reportError(this, re); 10049 _errHandler.recover(this, re); 10050 } 10051 finally { 10052 exitRule(); 10053 } 10054 return _localctx; 10055 } 10056 10057 public static class TfootTagOpenContext extends ParserRuleContext { 10058 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10059 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10060 public TerminalNode NEWLINE(int i) { 10061 return getToken(JavadocParser.NEWLINE, i); 10062 } 10063 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10064 public List<AttributeContext> attribute() { 10065 return getRuleContexts(AttributeContext.class); 10066 } 10067 public AttributeContext attribute(int i) { 10068 return getRuleContext(AttributeContext.class,i); 10069 } 10070 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10071 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10072 public TerminalNode LEADING_ASTERISK(int i) { 10073 return getToken(JavadocParser.LEADING_ASTERISK, i); 10074 } 10075 public TerminalNode WS(int i) { 10076 return getToken(JavadocParser.WS, i); 10077 } 10078 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10079 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10080 super(parent, invokingState); 10081 } 10082 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10083 @Override 10084 public void enterRule(ParseTreeListener listener) { 10085 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10086 } 10087 @Override 10088 public void exitRule(ParseTreeListener listener) { 10089 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10090 } 10091 @Override 10092 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10093 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10094 else return visitor.visitChildren(this); 10095 } 10096 } 10097 10098 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10099 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10100 enterRule(_localctx, 90, RULE_tfootTagOpen); 10101 int _la; 10102 try { 10103 enterOuterAlt(_localctx, 1); 10104 { 10105 setState(1203); match(OPEN); 10106 setState(1204); match(TFOOT_HTML_TAG_NAME); 10107 setState(1211); 10108 _errHandler.sync(this); 10109 _la = _input.LA(1); 10110 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10111 { 10112 setState(1209); 10113 switch (_input.LA(1)) { 10114 case HTML_TAG_NAME: 10115 { 10116 setState(1205); attribute(); 10117 } 10118 break; 10119 case NEWLINE: 10120 { 10121 setState(1206); match(NEWLINE); 10122 } 10123 break; 10124 case LEADING_ASTERISK: 10125 { 10126 setState(1207); match(LEADING_ASTERISK); 10127 } 10128 break; 10129 case WS: 10130 { 10131 setState(1208); match(WS); 10132 } 10133 break; 10134 default: 10135 throw new NoViableAltException(this); 10136 } 10137 } 10138 setState(1213); 10139 _errHandler.sync(this); 10140 _la = _input.LA(1); 10141 } 10142 setState(1214); match(CLOSE); 10143 } 10144 } 10145 catch (RecognitionException re) { 10146 _localctx.exception = re; 10147 _errHandler.reportError(this, re); 10148 _errHandler.recover(this, re); 10149 } 10150 finally { 10151 exitRule(); 10152 } 10153 return _localctx; 10154 } 10155 10156 public static class TfootTagCloseContext extends ParserRuleContext { 10157 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10158 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10159 public TerminalNode NEWLINE(int i) { 10160 return getToken(JavadocParser.NEWLINE, i); 10161 } 10162 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10163 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10164 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10165 public TerminalNode LEADING_ASTERISK(int i) { 10166 return getToken(JavadocParser.LEADING_ASTERISK, i); 10167 } 10168 public TerminalNode WS(int i) { 10169 return getToken(JavadocParser.WS, i); 10170 } 10171 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10172 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10173 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10174 super(parent, invokingState); 10175 } 10176 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10177 @Override 10178 public void enterRule(ParseTreeListener listener) { 10179 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10180 } 10181 @Override 10182 public void exitRule(ParseTreeListener listener) { 10183 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10184 } 10185 @Override 10186 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10187 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10188 else return visitor.visitChildren(this); 10189 } 10190 } 10191 10192 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10193 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10194 enterRule(_localctx, 92, RULE_tfootTagClose); 10195 int _la; 10196 try { 10197 enterOuterAlt(_localctx, 1); 10198 { 10199 setState(1216); match(OPEN); 10200 setState(1217); match(SLASH); 10201 setState(1218); match(TFOOT_HTML_TAG_NAME); 10202 setState(1222); 10203 _errHandler.sync(this); 10204 _la = _input.LA(1); 10205 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10206 { 10207 { 10208 setState(1219); 10209 _la = _input.LA(1); 10210 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10211 _errHandler.recoverInline(this); 10212 } 10213 consume(); 10214 } 10215 } 10216 setState(1224); 10217 _errHandler.sync(this); 10218 _la = _input.LA(1); 10219 } 10220 setState(1225); match(CLOSE); 10221 } 10222 } 10223 catch (RecognitionException re) { 10224 _localctx.exception = re; 10225 _errHandler.reportError(this, re); 10226 _errHandler.recover(this, re); 10227 } 10228 finally { 10229 exitRule(); 10230 } 10231 return _localctx; 10232 } 10233 10234 public static class TfootContext extends ParserRuleContext { 10235 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10236 return getRuleContexts(ColgroupTagOpenContext.class); 10237 } 10238 public TbodyContext tbody(int i) { 10239 return getRuleContext(TbodyContext.class,i); 10240 } 10241 public TerminalNode CDATA(int i) { 10242 return getToken(JavadocParser.CDATA, i); 10243 } 10244 public List<DtTagOpenContext> dtTagOpen() { 10245 return getRuleContexts(DtTagOpenContext.class); 10246 } 10247 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10248 public List<ColgroupContext> colgroup() { 10249 return getRuleContexts(ColgroupContext.class); 10250 } 10251 public HeadContext head(int i) { 10252 return getRuleContext(HeadContext.class,i); 10253 } 10254 public List<TrContext> tr() { 10255 return getRuleContexts(TrContext.class); 10256 } 10257 public List<LiContext> li() { 10258 return getRuleContexts(LiContext.class); 10259 } 10260 public ThTagOpenContext thTagOpen(int i) { 10261 return getRuleContext(ThTagOpenContext.class,i); 10262 } 10263 public List<DdTagOpenContext> ddTagOpen() { 10264 return getRuleContexts(DdTagOpenContext.class); 10265 } 10266 public ColgroupContext colgroup(int i) { 10267 return getRuleContext(ColgroupContext.class,i); 10268 } 10269 public TdTagOpenContext tdTagOpen(int i) { 10270 return getRuleContext(TdTagOpenContext.class,i); 10271 } 10272 public List<ThTagOpenContext> thTagOpen() { 10273 return getRuleContexts(ThTagOpenContext.class); 10274 } 10275 public List<HeadTagOpenContext> headTagOpen() { 10276 return getRuleContexts(HeadTagOpenContext.class); 10277 } 10278 public List<HtmlTagOpenContext> htmlTagOpen() { 10279 return getRuleContexts(HtmlTagOpenContext.class); 10280 } 10281 public List<TbodyTagOpenContext> tbodyTagOpen() { 10282 return getRuleContexts(TbodyTagOpenContext.class); 10283 } 10284 public List<TheadContext> thead() { 10285 return getRuleContexts(TheadContext.class); 10286 } 10287 public LiContext li(int i) { 10288 return getRuleContext(LiContext.class,i); 10289 } 10290 public TfootTagOpenContext tfootTagOpen() { 10291 return getRuleContext(TfootTagOpenContext.class,0); 10292 } 10293 public List<JavadocInlineTagContext> javadocInlineTag() { 10294 return getRuleContexts(JavadocInlineTagContext.class); 10295 } 10296 public List<HtmlCommentContext> htmlComment() { 10297 return getRuleContexts(HtmlCommentContext.class); 10298 } 10299 public OptionContext option(int i) { 10300 return getRuleContext(OptionContext.class,i); 10301 } 10302 public TrContext tr(int i) { 10303 return getRuleContext(TrContext.class,i); 10304 } 10305 public List<DtContext> dt() { 10306 return getRuleContexts(DtContext.class); 10307 } 10308 public HtmlCommentContext htmlComment(int i) { 10309 return getRuleContext(HtmlCommentContext.class,i); 10310 } 10311 public List<TdContext> td() { 10312 return getRuleContexts(TdContext.class); 10313 } 10314 public List<BodyTagOpenContext> bodyTagOpen() { 10315 return getRuleContexts(BodyTagOpenContext.class); 10316 } 10317 public DtTagOpenContext dtTagOpen(int i) { 10318 return getRuleContext(DtTagOpenContext.class,i); 10319 } 10320 public HtmlContext html(int i) { 10321 return getRuleContext(HtmlContext.class,i); 10322 } 10323 public BodyTagOpenContext bodyTagOpen(int i) { 10324 return getRuleContext(BodyTagOpenContext.class,i); 10325 } 10326 public DdTagOpenContext ddTagOpen(int i) { 10327 return getRuleContext(DdTagOpenContext.class,i); 10328 } 10329 public List<HtmlTagContext> htmlTag() { 10330 return getRuleContexts(HtmlTagContext.class); 10331 } 10332 public ParagraphContext paragraph(int i) { 10333 return getRuleContext(ParagraphContext.class,i); 10334 } 10335 public List<TdTagOpenContext> tdTagOpen() { 10336 return getRuleContexts(TdTagOpenContext.class); 10337 } 10338 public OptionTagOpenContext optionTagOpen(int i) { 10339 return getRuleContext(OptionTagOpenContext.class,i); 10340 } 10341 public LiTagOpenContext liTagOpen(int i) { 10342 return getRuleContext(LiTagOpenContext.class,i); 10343 } 10344 public TdContext td(int i) { 10345 return getRuleContext(TdContext.class,i); 10346 } 10347 public List<ParagraphContext> paragraph() { 10348 return getRuleContexts(ParagraphContext.class); 10349 } 10350 public HtmlTagContext htmlTag(int i) { 10351 return getRuleContext(HtmlTagContext.class,i); 10352 } 10353 public List<SingletonTagContext> singletonTag() { 10354 return getRuleContexts(SingletonTagContext.class); 10355 } 10356 public HeadTagOpenContext headTagOpen(int i) { 10357 return getRuleContext(HeadTagOpenContext.class,i); 10358 } 10359 public TrTagOpenContext trTagOpen(int i) { 10360 return getRuleContext(TrTagOpenContext.class,i); 10361 } 10362 public List<HtmlContext> html() { 10363 return getRuleContexts(HtmlContext.class); 10364 } 10365 public JavadocInlineTagContext javadocInlineTag(int i) { 10366 return getRuleContext(JavadocInlineTagContext.class,i); 10367 } 10368 public List<ThContext> th() { 10369 return getRuleContexts(ThContext.class); 10370 } 10371 public DtContext dt(int i) { 10372 return getRuleContext(DtContext.class,i); 10373 } 10374 public PTagOpenContext pTagOpen(int i) { 10375 return getRuleContext(PTagOpenContext.class,i); 10376 } 10377 public TerminalNode LEADING_ASTERISK(int i) { 10378 return getToken(JavadocParser.LEADING_ASTERISK, i); 10379 } 10380 public List<TrTagOpenContext> trTagOpen() { 10381 return getRuleContexts(TrTagOpenContext.class); 10382 } 10383 public List<TbodyContext> tbody() { 10384 return getRuleContexts(TbodyContext.class); 10385 } 10386 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10387 public List<TheadTagOpenContext> theadTagOpen() { 10388 return getRuleContexts(TheadTagOpenContext.class); 10389 } 10390 public List<HeadContext> head() { 10391 return getRuleContexts(HeadContext.class); 10392 } 10393 public TerminalNode NEWLINE(int i) { 10394 return getToken(JavadocParser.NEWLINE, i); 10395 } 10396 public TextContext text(int i) { 10397 return getRuleContext(TextContext.class,i); 10398 } 10399 public List<BodyContext> body() { 10400 return getRuleContexts(BodyContext.class); 10401 } 10402 public List<OptionTagOpenContext> optionTagOpen() { 10403 return getRuleContexts(OptionTagOpenContext.class); 10404 } 10405 public TfootTagCloseContext tfootTagClose() { 10406 return getRuleContext(TfootTagCloseContext.class,0); 10407 } 10408 public List<TextContext> text() { 10409 return getRuleContexts(TextContext.class); 10410 } 10411 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10412 public TbodyTagOpenContext tbodyTagOpen(int i) { 10413 return getRuleContext(TbodyTagOpenContext.class,i); 10414 } 10415 public List<DdContext> dd() { 10416 return getRuleContexts(DdContext.class); 10417 } 10418 public TheadTagOpenContext theadTagOpen(int i) { 10419 return getRuleContext(TheadTagOpenContext.class,i); 10420 } 10421 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10422 return getRuleContext(ColgroupTagOpenContext.class,i); 10423 } 10424 public List<LiTagOpenContext> liTagOpen() { 10425 return getRuleContexts(LiTagOpenContext.class); 10426 } 10427 public DdContext dd(int i) { 10428 return getRuleContext(DdContext.class,i); 10429 } 10430 public List<OptionContext> option() { 10431 return getRuleContexts(OptionContext.class); 10432 } 10433 public TheadContext thead(int i) { 10434 return getRuleContext(TheadContext.class,i); 10435 } 10436 public BodyContext body(int i) { 10437 return getRuleContext(BodyContext.class,i); 10438 } 10439 public ThContext th(int i) { 10440 return getRuleContext(ThContext.class,i); 10441 } 10442 public List<PTagOpenContext> pTagOpen() { 10443 return getRuleContexts(PTagOpenContext.class); 10444 } 10445 public HtmlTagOpenContext htmlTagOpen(int i) { 10446 return getRuleContext(HtmlTagOpenContext.class,i); 10447 } 10448 public SingletonTagContext singletonTag(int i) { 10449 return getRuleContext(SingletonTagContext.class,i); 10450 } 10451 public TfootContext(ParserRuleContext parent, int invokingState) { 10452 super(parent, invokingState); 10453 } 10454 @Override public int getRuleIndex() { return RULE_tfoot; } 10455 @Override 10456 public void enterRule(ParseTreeListener listener) { 10457 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10458 } 10459 @Override 10460 public void exitRule(ParseTreeListener listener) { 10461 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10462 } 10463 @Override 10464 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10465 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10466 else return visitor.visitChildren(this); 10467 } 10468 } 10469 10470 public final TfootContext tfoot() throws RecognitionException { 10471 TfootContext _localctx = new TfootContext(_ctx, getState()); 10472 enterRule(_localctx, 94, RULE_tfoot); 10473 try { 10474 int _alt; 10475 enterOuterAlt(_localctx, 1); 10476 { 10477 setState(1227); tfootTagOpen(); 10478 setState(1267); 10479 _errHandler.sync(this); 10480 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10481 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10482 if ( _alt==1 ) { 10483 { 10484 setState(1265); 10485 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10486 case 1: 10487 { 10488 setState(1228); htmlTag(); 10489 } 10490 break; 10491 10492 case 2: 10493 { 10494 setState(1229); singletonTag(); 10495 } 10496 break; 10497 10498 case 3: 10499 { 10500 setState(1230); paragraph(); 10501 } 10502 break; 10503 10504 case 4: 10505 { 10506 setState(1231); li(); 10507 } 10508 break; 10509 10510 case 5: 10511 { 10512 setState(1232); tr(); 10513 } 10514 break; 10515 10516 case 6: 10517 { 10518 setState(1233); td(); 10519 } 10520 break; 10521 10522 case 7: 10523 { 10524 setState(1234); th(); 10525 } 10526 break; 10527 10528 case 8: 10529 { 10530 setState(1235); body(); 10531 } 10532 break; 10533 10534 case 9: 10535 { 10536 setState(1236); colgroup(); 10537 } 10538 break; 10539 10540 case 10: 10541 { 10542 setState(1237); dd(); 10543 } 10544 break; 10545 10546 case 11: 10547 { 10548 setState(1238); dt(); 10549 } 10550 break; 10551 10552 case 12: 10553 { 10554 setState(1239); head(); 10555 } 10556 break; 10557 10558 case 13: 10559 { 10560 setState(1240); html(); 10561 } 10562 break; 10563 10564 case 14: 10565 { 10566 setState(1241); option(); 10567 } 10568 break; 10569 10570 case 15: 10571 { 10572 setState(1242); tbody(); 10573 } 10574 break; 10575 10576 case 16: 10577 { 10578 setState(1243); thead(); 10579 } 10580 break; 10581 10582 case 17: 10583 { 10584 setState(1244); pTagOpen(); 10585 } 10586 break; 10587 10588 case 18: 10589 { 10590 setState(1245); liTagOpen(); 10591 } 10592 break; 10593 10594 case 19: 10595 { 10596 setState(1246); trTagOpen(); 10597 } 10598 break; 10599 10600 case 20: 10601 { 10602 setState(1247); tdTagOpen(); 10603 } 10604 break; 10605 10606 case 21: 10607 { 10608 setState(1248); thTagOpen(); 10609 } 10610 break; 10611 10612 case 22: 10613 { 10614 setState(1249); bodyTagOpen(); 10615 } 10616 break; 10617 10618 case 23: 10619 { 10620 setState(1250); colgroupTagOpen(); 10621 } 10622 break; 10623 10624 case 24: 10625 { 10626 setState(1251); ddTagOpen(); 10627 } 10628 break; 10629 10630 case 25: 10631 { 10632 setState(1252); dtTagOpen(); 10633 } 10634 break; 10635 10636 case 26: 10637 { 10638 setState(1253); headTagOpen(); 10639 } 10640 break; 10641 10642 case 27: 10643 { 10644 setState(1254); htmlTagOpen(); 10645 } 10646 break; 10647 10648 case 28: 10649 { 10650 setState(1255); optionTagOpen(); 10651 } 10652 break; 10653 10654 case 29: 10655 { 10656 setState(1256); tbodyTagOpen(); 10657 } 10658 break; 10659 10660 case 30: 10661 { 10662 setState(1257); theadTagOpen(); 10663 } 10664 break; 10665 10666 case 31: 10667 { 10668 { 10669 setState(1258); 10670 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10671 setState(1259); match(LEADING_ASTERISK); 10672 } 10673 } 10674 break; 10675 10676 case 32: 10677 { 10678 setState(1260); htmlComment(); 10679 } 10680 break; 10681 10682 case 33: 10683 { 10684 setState(1261); match(CDATA); 10685 } 10686 break; 10687 10688 case 34: 10689 { 10690 setState(1262); match(NEWLINE); 10691 } 10692 break; 10693 10694 case 35: 10695 { 10696 setState(1263); text(); 10697 } 10698 break; 10699 10700 case 36: 10701 { 10702 setState(1264); javadocInlineTag(); 10703 } 10704 break; 10705 } 10706 } 10707 } 10708 setState(1269); 10709 _errHandler.sync(this); 10710 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10711 } 10712 setState(1270); tfootTagClose(); 10713 } 10714 } 10715 catch (RecognitionException re) { 10716 _localctx.exception = re; 10717 _errHandler.reportError(this, re); 10718 _errHandler.recover(this, re); 10719 } 10720 finally { 10721 exitRule(); 10722 } 10723 return _localctx; 10724 } 10725 10726 public static class TheadTagOpenContext extends ParserRuleContext { 10727 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10728 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10729 public TerminalNode NEWLINE(int i) { 10730 return getToken(JavadocParser.NEWLINE, i); 10731 } 10732 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10733 public List<AttributeContext> attribute() { 10734 return getRuleContexts(AttributeContext.class); 10735 } 10736 public AttributeContext attribute(int i) { 10737 return getRuleContext(AttributeContext.class,i); 10738 } 10739 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10740 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10741 public TerminalNode LEADING_ASTERISK(int i) { 10742 return getToken(JavadocParser.LEADING_ASTERISK, i); 10743 } 10744 public TerminalNode WS(int i) { 10745 return getToken(JavadocParser.WS, i); 10746 } 10747 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 10748 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 10749 super(parent, invokingState); 10750 } 10751 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 10752 @Override 10753 public void enterRule(ParseTreeListener listener) { 10754 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 10755 } 10756 @Override 10757 public void exitRule(ParseTreeListener listener) { 10758 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 10759 } 10760 @Override 10761 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10762 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 10763 else return visitor.visitChildren(this); 10764 } 10765 } 10766 10767 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 10768 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 10769 enterRule(_localctx, 96, RULE_theadTagOpen); 10770 int _la; 10771 try { 10772 enterOuterAlt(_localctx, 1); 10773 { 10774 setState(1272); match(OPEN); 10775 setState(1273); match(THEAD_HTML_TAG_NAME); 10776 setState(1280); 10777 _errHandler.sync(this); 10778 _la = _input.LA(1); 10779 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10780 { 10781 setState(1278); 10782 switch (_input.LA(1)) { 10783 case HTML_TAG_NAME: 10784 { 10785 setState(1274); attribute(); 10786 } 10787 break; 10788 case NEWLINE: 10789 { 10790 setState(1275); match(NEWLINE); 10791 } 10792 break; 10793 case LEADING_ASTERISK: 10794 { 10795 setState(1276); match(LEADING_ASTERISK); 10796 } 10797 break; 10798 case WS: 10799 { 10800 setState(1277); match(WS); 10801 } 10802 break; 10803 default: 10804 throw new NoViableAltException(this); 10805 } 10806 } 10807 setState(1282); 10808 _errHandler.sync(this); 10809 _la = _input.LA(1); 10810 } 10811 setState(1283); match(CLOSE); 10812 } 10813 } 10814 catch (RecognitionException re) { 10815 _localctx.exception = re; 10816 _errHandler.reportError(this, re); 10817 _errHandler.recover(this, re); 10818 } 10819 finally { 10820 exitRule(); 10821 } 10822 return _localctx; 10823 } 10824 10825 public static class TheadTagCloseContext extends ParserRuleContext { 10826 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10827 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10828 public TerminalNode NEWLINE(int i) { 10829 return getToken(JavadocParser.NEWLINE, i); 10830 } 10831 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10832 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10833 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10834 public TerminalNode LEADING_ASTERISK(int i) { 10835 return getToken(JavadocParser.LEADING_ASTERISK, i); 10836 } 10837 public TerminalNode WS(int i) { 10838 return getToken(JavadocParser.WS, i); 10839 } 10840 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 10841 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10842 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 10843 super(parent, invokingState); 10844 } 10845 @Override public int getRuleIndex() { return RULE_theadTagClose; } 10846 @Override 10847 public void enterRule(ParseTreeListener listener) { 10848 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 10849 } 10850 @Override 10851 public void exitRule(ParseTreeListener listener) { 10852 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 10853 } 10854 @Override 10855 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10856 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 10857 else return visitor.visitChildren(this); 10858 } 10859 } 10860 10861 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 10862 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 10863 enterRule(_localctx, 98, RULE_theadTagClose); 10864 int _la; 10865 try { 10866 enterOuterAlt(_localctx, 1); 10867 { 10868 setState(1285); match(OPEN); 10869 setState(1286); match(SLASH); 10870 setState(1287); match(THEAD_HTML_TAG_NAME); 10871 setState(1291); 10872 _errHandler.sync(this); 10873 _la = _input.LA(1); 10874 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10875 { 10876 { 10877 setState(1288); 10878 _la = _input.LA(1); 10879 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10880 _errHandler.recoverInline(this); 10881 } 10882 consume(); 10883 } 10884 } 10885 setState(1293); 10886 _errHandler.sync(this); 10887 _la = _input.LA(1); 10888 } 10889 setState(1294); match(CLOSE); 10890 } 10891 } 10892 catch (RecognitionException re) { 10893 _localctx.exception = re; 10894 _errHandler.reportError(this, re); 10895 _errHandler.recover(this, re); 10896 } 10897 finally { 10898 exitRule(); 10899 } 10900 return _localctx; 10901 } 10902 10903 public static class TheadContext extends ParserRuleContext { 10904 public TheadTagCloseContext theadTagClose() { 10905 return getRuleContext(TheadTagCloseContext.class,0); 10906 } 10907 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10908 return getRuleContexts(ColgroupTagOpenContext.class); 10909 } 10910 public TbodyContext tbody(int i) { 10911 return getRuleContext(TbodyContext.class,i); 10912 } 10913 public TerminalNode CDATA(int i) { 10914 return getToken(JavadocParser.CDATA, i); 10915 } 10916 public TfootTagOpenContext tfootTagOpen(int i) { 10917 return getRuleContext(TfootTagOpenContext.class,i); 10918 } 10919 public List<DtTagOpenContext> dtTagOpen() { 10920 return getRuleContexts(DtTagOpenContext.class); 10921 } 10922 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10923 public List<ColgroupContext> colgroup() { 10924 return getRuleContexts(ColgroupContext.class); 10925 } 10926 public HeadContext head(int i) { 10927 return getRuleContext(HeadContext.class,i); 10928 } 10929 public List<TrContext> tr() { 10930 return getRuleContexts(TrContext.class); 10931 } 10932 public List<LiContext> li() { 10933 return getRuleContexts(LiContext.class); 10934 } 10935 public ThTagOpenContext thTagOpen(int i) { 10936 return getRuleContext(ThTagOpenContext.class,i); 10937 } 10938 public List<DdTagOpenContext> ddTagOpen() { 10939 return getRuleContexts(DdTagOpenContext.class); 10940 } 10941 public ColgroupContext colgroup(int i) { 10942 return getRuleContext(ColgroupContext.class,i); 10943 } 10944 public TdTagOpenContext tdTagOpen(int i) { 10945 return getRuleContext(TdTagOpenContext.class,i); 10946 } 10947 public List<ThTagOpenContext> thTagOpen() { 10948 return getRuleContexts(ThTagOpenContext.class); 10949 } 10950 public List<HeadTagOpenContext> headTagOpen() { 10951 return getRuleContexts(HeadTagOpenContext.class); 10952 } 10953 public List<HtmlTagOpenContext> htmlTagOpen() { 10954 return getRuleContexts(HtmlTagOpenContext.class); 10955 } 10956 public List<TbodyTagOpenContext> tbodyTagOpen() { 10957 return getRuleContexts(TbodyTagOpenContext.class); 10958 } 10959 public LiContext li(int i) { 10960 return getRuleContext(LiContext.class,i); 10961 } 10962 public List<TfootTagOpenContext> tfootTagOpen() { 10963 return getRuleContexts(TfootTagOpenContext.class); 10964 } 10965 public List<TfootContext> tfoot() { 10966 return getRuleContexts(TfootContext.class); 10967 } 10968 public List<JavadocInlineTagContext> javadocInlineTag() { 10969 return getRuleContexts(JavadocInlineTagContext.class); 10970 } 10971 public List<HtmlCommentContext> htmlComment() { 10972 return getRuleContexts(HtmlCommentContext.class); 10973 } 10974 public OptionContext option(int i) { 10975 return getRuleContext(OptionContext.class,i); 10976 } 10977 public TrContext tr(int i) { 10978 return getRuleContext(TrContext.class,i); 10979 } 10980 public List<DtContext> dt() { 10981 return getRuleContexts(DtContext.class); 10982 } 10983 public HtmlCommentContext htmlComment(int i) { 10984 return getRuleContext(HtmlCommentContext.class,i); 10985 } 10986 public List<TdContext> td() { 10987 return getRuleContexts(TdContext.class); 10988 } 10989 public List<BodyTagOpenContext> bodyTagOpen() { 10990 return getRuleContexts(BodyTagOpenContext.class); 10991 } 10992 public DtTagOpenContext dtTagOpen(int i) { 10993 return getRuleContext(DtTagOpenContext.class,i); 10994 } 10995 public HtmlContext html(int i) { 10996 return getRuleContext(HtmlContext.class,i); 10997 } 10998 public BodyTagOpenContext bodyTagOpen(int i) { 10999 return getRuleContext(BodyTagOpenContext.class,i); 11000 } 11001 public DdTagOpenContext ddTagOpen(int i) { 11002 return getRuleContext(DdTagOpenContext.class,i); 11003 } 11004 public List<HtmlTagContext> htmlTag() { 11005 return getRuleContexts(HtmlTagContext.class); 11006 } 11007 public ParagraphContext paragraph(int i) { 11008 return getRuleContext(ParagraphContext.class,i); 11009 } 11010 public List<TdTagOpenContext> tdTagOpen() { 11011 return getRuleContexts(TdTagOpenContext.class); 11012 } 11013 public OptionTagOpenContext optionTagOpen(int i) { 11014 return getRuleContext(OptionTagOpenContext.class,i); 11015 } 11016 public LiTagOpenContext liTagOpen(int i) { 11017 return getRuleContext(LiTagOpenContext.class,i); 11018 } 11019 public TdContext td(int i) { 11020 return getRuleContext(TdContext.class,i); 11021 } 11022 public List<ParagraphContext> paragraph() { 11023 return getRuleContexts(ParagraphContext.class); 11024 } 11025 public HtmlTagContext htmlTag(int i) { 11026 return getRuleContext(HtmlTagContext.class,i); 11027 } 11028 public List<SingletonTagContext> singletonTag() { 11029 return getRuleContexts(SingletonTagContext.class); 11030 } 11031 public HeadTagOpenContext headTagOpen(int i) { 11032 return getRuleContext(HeadTagOpenContext.class,i); 11033 } 11034 public TrTagOpenContext trTagOpen(int i) { 11035 return getRuleContext(TrTagOpenContext.class,i); 11036 } 11037 public List<HtmlContext> html() { 11038 return getRuleContexts(HtmlContext.class); 11039 } 11040 public JavadocInlineTagContext javadocInlineTag(int i) { 11041 return getRuleContext(JavadocInlineTagContext.class,i); 11042 } 11043 public List<ThContext> th() { 11044 return getRuleContexts(ThContext.class); 11045 } 11046 public DtContext dt(int i) { 11047 return getRuleContext(DtContext.class,i); 11048 } 11049 public PTagOpenContext pTagOpen(int i) { 11050 return getRuleContext(PTagOpenContext.class,i); 11051 } 11052 public TerminalNode LEADING_ASTERISK(int i) { 11053 return getToken(JavadocParser.LEADING_ASTERISK, i); 11054 } 11055 public List<TrTagOpenContext> trTagOpen() { 11056 return getRuleContexts(TrTagOpenContext.class); 11057 } 11058 public List<TbodyContext> tbody() { 11059 return getRuleContexts(TbodyContext.class); 11060 } 11061 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11062 public TheadTagOpenContext theadTagOpen() { 11063 return getRuleContext(TheadTagOpenContext.class,0); 11064 } 11065 public List<HeadContext> head() { 11066 return getRuleContexts(HeadContext.class); 11067 } 11068 public TerminalNode NEWLINE(int i) { 11069 return getToken(JavadocParser.NEWLINE, i); 11070 } 11071 public TextContext text(int i) { 11072 return getRuleContext(TextContext.class,i); 11073 } 11074 public List<BodyContext> body() { 11075 return getRuleContexts(BodyContext.class); 11076 } 11077 public List<OptionTagOpenContext> optionTagOpen() { 11078 return getRuleContexts(OptionTagOpenContext.class); 11079 } 11080 public List<TextContext> text() { 11081 return getRuleContexts(TextContext.class); 11082 } 11083 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11084 public TbodyTagOpenContext tbodyTagOpen(int i) { 11085 return getRuleContext(TbodyTagOpenContext.class,i); 11086 } 11087 public List<DdContext> dd() { 11088 return getRuleContexts(DdContext.class); 11089 } 11090 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11091 return getRuleContext(ColgroupTagOpenContext.class,i); 11092 } 11093 public List<LiTagOpenContext> liTagOpen() { 11094 return getRuleContexts(LiTagOpenContext.class); 11095 } 11096 public DdContext dd(int i) { 11097 return getRuleContext(DdContext.class,i); 11098 } 11099 public List<OptionContext> option() { 11100 return getRuleContexts(OptionContext.class); 11101 } 11102 public BodyContext body(int i) { 11103 return getRuleContext(BodyContext.class,i); 11104 } 11105 public ThContext th(int i) { 11106 return getRuleContext(ThContext.class,i); 11107 } 11108 public List<PTagOpenContext> pTagOpen() { 11109 return getRuleContexts(PTagOpenContext.class); 11110 } 11111 public HtmlTagOpenContext htmlTagOpen(int i) { 11112 return getRuleContext(HtmlTagOpenContext.class,i); 11113 } 11114 public SingletonTagContext singletonTag(int i) { 11115 return getRuleContext(SingletonTagContext.class,i); 11116 } 11117 public TfootContext tfoot(int i) { 11118 return getRuleContext(TfootContext.class,i); 11119 } 11120 public TheadContext(ParserRuleContext parent, int invokingState) { 11121 super(parent, invokingState); 11122 } 11123 @Override public int getRuleIndex() { return RULE_thead; } 11124 @Override 11125 public void enterRule(ParseTreeListener listener) { 11126 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11127 } 11128 @Override 11129 public void exitRule(ParseTreeListener listener) { 11130 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11131 } 11132 @Override 11133 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11134 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11135 else return visitor.visitChildren(this); 11136 } 11137 } 11138 11139 public final TheadContext thead() throws RecognitionException { 11140 TheadContext _localctx = new TheadContext(_ctx, getState()); 11141 enterRule(_localctx, 100, RULE_thead); 11142 try { 11143 int _alt; 11144 enterOuterAlt(_localctx, 1); 11145 { 11146 setState(1296); theadTagOpen(); 11147 setState(1336); 11148 _errHandler.sync(this); 11149 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11150 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11151 if ( _alt==1 ) { 11152 { 11153 setState(1334); 11154 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11155 case 1: 11156 { 11157 setState(1297); htmlTag(); 11158 } 11159 break; 11160 11161 case 2: 11162 { 11163 setState(1298); singletonTag(); 11164 } 11165 break; 11166 11167 case 3: 11168 { 11169 setState(1299); paragraph(); 11170 } 11171 break; 11172 11173 case 4: 11174 { 11175 setState(1300); li(); 11176 } 11177 break; 11178 11179 case 5: 11180 { 11181 setState(1301); tr(); 11182 } 11183 break; 11184 11185 case 6: 11186 { 11187 setState(1302); td(); 11188 } 11189 break; 11190 11191 case 7: 11192 { 11193 setState(1303); th(); 11194 } 11195 break; 11196 11197 case 8: 11198 { 11199 setState(1304); body(); 11200 } 11201 break; 11202 11203 case 9: 11204 { 11205 setState(1305); colgroup(); 11206 } 11207 break; 11208 11209 case 10: 11210 { 11211 setState(1306); dd(); 11212 } 11213 break; 11214 11215 case 11: 11216 { 11217 setState(1307); dt(); 11218 } 11219 break; 11220 11221 case 12: 11222 { 11223 setState(1308); head(); 11224 } 11225 break; 11226 11227 case 13: 11228 { 11229 setState(1309); html(); 11230 } 11231 break; 11232 11233 case 14: 11234 { 11235 setState(1310); option(); 11236 } 11237 break; 11238 11239 case 15: 11240 { 11241 setState(1311); tbody(); 11242 } 11243 break; 11244 11245 case 16: 11246 { 11247 setState(1312); tfoot(); 11248 } 11249 break; 11250 11251 case 17: 11252 { 11253 setState(1313); pTagOpen(); 11254 } 11255 break; 11256 11257 case 18: 11258 { 11259 setState(1314); liTagOpen(); 11260 } 11261 break; 11262 11263 case 19: 11264 { 11265 setState(1315); trTagOpen(); 11266 } 11267 break; 11268 11269 case 20: 11270 { 11271 setState(1316); tdTagOpen(); 11272 } 11273 break; 11274 11275 case 21: 11276 { 11277 setState(1317); thTagOpen(); 11278 } 11279 break; 11280 11281 case 22: 11282 { 11283 setState(1318); bodyTagOpen(); 11284 } 11285 break; 11286 11287 case 23: 11288 { 11289 setState(1319); colgroupTagOpen(); 11290 } 11291 break; 11292 11293 case 24: 11294 { 11295 setState(1320); ddTagOpen(); 11296 } 11297 break; 11298 11299 case 25: 11300 { 11301 setState(1321); dtTagOpen(); 11302 } 11303 break; 11304 11305 case 26: 11306 { 11307 setState(1322); headTagOpen(); 11308 } 11309 break; 11310 11311 case 27: 11312 { 11313 setState(1323); htmlTagOpen(); 11314 } 11315 break; 11316 11317 case 28: 11318 { 11319 setState(1324); optionTagOpen(); 11320 } 11321 break; 11322 11323 case 29: 11324 { 11325 setState(1325); tbodyTagOpen(); 11326 } 11327 break; 11328 11329 case 30: 11330 { 11331 setState(1326); tfootTagOpen(); 11332 } 11333 break; 11334 11335 case 31: 11336 { 11337 { 11338 setState(1327); 11339 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11340 setState(1328); match(LEADING_ASTERISK); 11341 } 11342 } 11343 break; 11344 11345 case 32: 11346 { 11347 setState(1329); htmlComment(); 11348 } 11349 break; 11350 11351 case 33: 11352 { 11353 setState(1330); match(CDATA); 11354 } 11355 break; 11356 11357 case 34: 11358 { 11359 setState(1331); match(NEWLINE); 11360 } 11361 break; 11362 11363 case 35: 11364 { 11365 setState(1332); text(); 11366 } 11367 break; 11368 11369 case 36: 11370 { 11371 setState(1333); javadocInlineTag(); 11372 } 11373 break; 11374 } 11375 } 11376 } 11377 setState(1338); 11378 _errHandler.sync(this); 11379 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11380 } 11381 setState(1339); theadTagClose(); 11382 } 11383 } 11384 catch (RecognitionException re) { 11385 _localctx.exception = re; 11386 _errHandler.reportError(this, re); 11387 _errHandler.recover(this, re); 11388 } 11389 finally { 11390 exitRule(); 11391 } 11392 return _localctx; 11393 } 11394 11395 public static class SingletonElementContext extends ParserRuleContext { 11396 public InputTagContext inputTag() { 11397 return getRuleContext(InputTagContext.class,0); 11398 } 11399 public ImgTagContext imgTag() { 11400 return getRuleContext(ImgTagContext.class,0); 11401 } 11402 public AreaTagContext areaTag() { 11403 return getRuleContext(AreaTagContext.class,0); 11404 } 11405 public IsindexTagContext isindexTag() { 11406 return getRuleContext(IsindexTagContext.class,0); 11407 } 11408 public SingletonTagContext singletonTag() { 11409 return getRuleContext(SingletonTagContext.class,0); 11410 } 11411 public LinkTagContext linkTag() { 11412 return getRuleContext(LinkTagContext.class,0); 11413 } 11414 public ColTagContext colTag() { 11415 return getRuleContext(ColTagContext.class,0); 11416 } 11417 public BasefrontTagContext basefrontTag() { 11418 return getRuleContext(BasefrontTagContext.class,0); 11419 } 11420 public ParamTagContext paramTag() { 11421 return getRuleContext(ParamTagContext.class,0); 11422 } 11423 public HrTagContext hrTag() { 11424 return getRuleContext(HrTagContext.class,0); 11425 } 11426 public MetaTagContext metaTag() { 11427 return getRuleContext(MetaTagContext.class,0); 11428 } 11429 public BaseTagContext baseTag() { 11430 return getRuleContext(BaseTagContext.class,0); 11431 } 11432 public FrameTagContext frameTag() { 11433 return getRuleContext(FrameTagContext.class,0); 11434 } 11435 public WrongSinletonTagContext wrongSinletonTag() { 11436 return getRuleContext(WrongSinletonTagContext.class,0); 11437 } 11438 public BrTagContext brTag() { 11439 return getRuleContext(BrTagContext.class,0); 11440 } 11441 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11442 super(parent, invokingState); 11443 } 11444 @Override public int getRuleIndex() { return RULE_singletonElement; } 11445 @Override 11446 public void enterRule(ParseTreeListener listener) { 11447 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11448 } 11449 @Override 11450 public void exitRule(ParseTreeListener listener) { 11451 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11452 } 11453 @Override 11454 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11455 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11456 else return visitor.visitChildren(this); 11457 } 11458 } 11459 11460 public final SingletonElementContext singletonElement() throws RecognitionException { 11461 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11462 enterRule(_localctx, 102, RULE_singletonElement); 11463 try { 11464 setState(1356); 11465 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11466 case 1: 11467 enterOuterAlt(_localctx, 1); 11468 { 11469 setState(1341); singletonTag(); 11470 } 11471 break; 11472 11473 case 2: 11474 enterOuterAlt(_localctx, 2); 11475 { 11476 setState(1342); areaTag(); 11477 } 11478 break; 11479 11480 case 3: 11481 enterOuterAlt(_localctx, 3); 11482 { 11483 setState(1343); baseTag(); 11484 } 11485 break; 11486 11487 case 4: 11488 enterOuterAlt(_localctx, 4); 11489 { 11490 setState(1344); basefrontTag(); 11491 } 11492 break; 11493 11494 case 5: 11495 enterOuterAlt(_localctx, 5); 11496 { 11497 setState(1345); brTag(); 11498 } 11499 break; 11500 11501 case 6: 11502 enterOuterAlt(_localctx, 6); 11503 { 11504 setState(1346); colTag(); 11505 } 11506 break; 11507 11508 case 7: 11509 enterOuterAlt(_localctx, 7); 11510 { 11511 setState(1347); frameTag(); 11512 } 11513 break; 11514 11515 case 8: 11516 enterOuterAlt(_localctx, 8); 11517 { 11518 setState(1348); hrTag(); 11519 } 11520 break; 11521 11522 case 9: 11523 enterOuterAlt(_localctx, 9); 11524 { 11525 setState(1349); imgTag(); 11526 } 11527 break; 11528 11529 case 10: 11530 enterOuterAlt(_localctx, 10); 11531 { 11532 setState(1350); inputTag(); 11533 } 11534 break; 11535 11536 case 11: 11537 enterOuterAlt(_localctx, 11); 11538 { 11539 setState(1351); isindexTag(); 11540 } 11541 break; 11542 11543 case 12: 11544 enterOuterAlt(_localctx, 12); 11545 { 11546 setState(1352); linkTag(); 11547 } 11548 break; 11549 11550 case 13: 11551 enterOuterAlt(_localctx, 13); 11552 { 11553 setState(1353); metaTag(); 11554 } 11555 break; 11556 11557 case 14: 11558 enterOuterAlt(_localctx, 14); 11559 { 11560 setState(1354); paramTag(); 11561 } 11562 break; 11563 11564 case 15: 11565 enterOuterAlt(_localctx, 15); 11566 { 11567 setState(1355); wrongSinletonTag(); 11568 } 11569 break; 11570 } 11571 } 11572 catch (RecognitionException re) { 11573 _localctx.exception = re; 11574 _errHandler.reportError(this, re); 11575 _errHandler.recover(this, re); 11576 } 11577 finally { 11578 exitRule(); 11579 } 11580 return _localctx; 11581 } 11582 11583 public static class SingletonTagContext extends ParserRuleContext { 11584 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11585 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11586 public AttributeContext attribute(int i) { 11587 return getRuleContext(AttributeContext.class,i); 11588 } 11589 public TerminalNode WS(int i) { 11590 return getToken(JavadocParser.WS, i); 11591 } 11592 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11593 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11594 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11595 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11596 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11597 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11598 public TerminalNode LEADING_ASTERISK(int i) { 11599 return getToken(JavadocParser.LEADING_ASTERISK, i); 11600 } 11601 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11602 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11603 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11604 public TerminalNode NEWLINE(int i) { 11605 return getToken(JavadocParser.NEWLINE, i); 11606 } 11607 public List<AttributeContext> attribute() { 11608 return getRuleContexts(AttributeContext.class); 11609 } 11610 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11611 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11612 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11613 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11614 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11615 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11616 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11617 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11618 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11619 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11620 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 11621 super(parent, invokingState); 11622 } 11623 @Override public int getRuleIndex() { return RULE_singletonTag; } 11624 @Override 11625 public void enterRule(ParseTreeListener listener) { 11626 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 11627 } 11628 @Override 11629 public void exitRule(ParseTreeListener listener) { 11630 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 11631 } 11632 @Override 11633 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11634 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 11635 else return visitor.visitChildren(this); 11636 } 11637 } 11638 11639 public final SingletonTagContext singletonTag() throws RecognitionException { 11640 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 11641 enterRule(_localctx, 104, RULE_singletonTag); 11642 int _la; 11643 try { 11644 enterOuterAlt(_localctx, 1); 11645 { 11646 setState(1358); match(OPEN); 11647 setState(1359); 11648 _la = _input.LA(1); 11649 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)) ) { 11650 _errHandler.recoverInline(this); 11651 } 11652 consume(); 11653 setState(1366); 11654 _errHandler.sync(this); 11655 _la = _input.LA(1); 11656 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11657 { 11658 setState(1364); 11659 switch (_input.LA(1)) { 11660 case HTML_TAG_NAME: 11661 { 11662 setState(1360); attribute(); 11663 } 11664 break; 11665 case NEWLINE: 11666 { 11667 setState(1361); match(NEWLINE); 11668 } 11669 break; 11670 case LEADING_ASTERISK: 11671 { 11672 setState(1362); match(LEADING_ASTERISK); 11673 } 11674 break; 11675 case WS: 11676 { 11677 setState(1363); match(WS); 11678 } 11679 break; 11680 default: 11681 throw new NoViableAltException(this); 11682 } 11683 } 11684 setState(1368); 11685 _errHandler.sync(this); 11686 _la = _input.LA(1); 11687 } 11688 setState(1369); match(SLASH_CLOSE); 11689 } 11690 } 11691 catch (RecognitionException re) { 11692 _localctx.exception = re; 11693 _errHandler.reportError(this, re); 11694 _errHandler.recover(this, re); 11695 } 11696 finally { 11697 exitRule(); 11698 } 11699 return _localctx; 11700 } 11701 11702 public static class AreaTagContext extends ParserRuleContext { 11703 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11704 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11705 public TerminalNode NEWLINE(int i) { 11706 return getToken(JavadocParser.NEWLINE, i); 11707 } 11708 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11709 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11710 public List<AttributeContext> attribute() { 11711 return getRuleContexts(AttributeContext.class); 11712 } 11713 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 11714 public AttributeContext attribute(int i) { 11715 return getRuleContext(AttributeContext.class,i); 11716 } 11717 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11718 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11719 public TerminalNode LEADING_ASTERISK(int i) { 11720 return getToken(JavadocParser.LEADING_ASTERISK, i); 11721 } 11722 public TerminalNode WS(int i) { 11723 return getToken(JavadocParser.WS, i); 11724 } 11725 public AreaTagContext(ParserRuleContext parent, int invokingState) { 11726 super(parent, invokingState); 11727 } 11728 @Override public int getRuleIndex() { return RULE_areaTag; } 11729 @Override 11730 public void enterRule(ParseTreeListener listener) { 11731 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 11732 } 11733 @Override 11734 public void exitRule(ParseTreeListener listener) { 11735 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 11736 } 11737 @Override 11738 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11739 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 11740 else return visitor.visitChildren(this); 11741 } 11742 } 11743 11744 public final AreaTagContext areaTag() throws RecognitionException { 11745 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 11746 enterRule(_localctx, 106, RULE_areaTag); 11747 int _la; 11748 try { 11749 enterOuterAlt(_localctx, 1); 11750 { 11751 setState(1371); match(OPEN); 11752 setState(1372); match(AREA_HTML_TAG_NAME); 11753 setState(1379); 11754 _errHandler.sync(this); 11755 _la = _input.LA(1); 11756 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11757 { 11758 setState(1377); 11759 switch (_input.LA(1)) { 11760 case HTML_TAG_NAME: 11761 { 11762 setState(1373); attribute(); 11763 } 11764 break; 11765 case NEWLINE: 11766 { 11767 setState(1374); match(NEWLINE); 11768 } 11769 break; 11770 case LEADING_ASTERISK: 11771 { 11772 setState(1375); match(LEADING_ASTERISK); 11773 } 11774 break; 11775 case WS: 11776 { 11777 setState(1376); match(WS); 11778 } 11779 break; 11780 default: 11781 throw new NoViableAltException(this); 11782 } 11783 } 11784 setState(1381); 11785 _errHandler.sync(this); 11786 _la = _input.LA(1); 11787 } 11788 setState(1382); 11789 _la = _input.LA(1); 11790 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 11791 _errHandler.recoverInline(this); 11792 } 11793 consume(); 11794 } 11795 } 11796 catch (RecognitionException re) { 11797 _localctx.exception = re; 11798 _errHandler.reportError(this, re); 11799 _errHandler.recover(this, re); 11800 } 11801 finally { 11802 exitRule(); 11803 } 11804 return _localctx; 11805 } 11806 11807 public static class BaseTagContext extends ParserRuleContext { 11808 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11809 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11810 public TerminalNode NEWLINE(int i) { 11811 return getToken(JavadocParser.NEWLINE, i); 11812 } 11813 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11814 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11815 public List<AttributeContext> attribute() { 11816 return getRuleContexts(AttributeContext.class); 11817 } 11818 public AttributeContext attribute(int i) { 11819 return getRuleContext(AttributeContext.class,i); 11820 } 11821 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11822 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 11823 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11824 public TerminalNode LEADING_ASTERISK(int i) { 11825 return getToken(JavadocParser.LEADING_ASTERISK, i); 11826 } 11827 public TerminalNode WS(int i) { 11828 return getToken(JavadocParser.WS, i); 11829 } 11830 public BaseTagContext(ParserRuleContext parent, int invokingState) { 11831 super(parent, invokingState); 11832 } 11833 @Override public int getRuleIndex() { return RULE_baseTag; } 11834 @Override 11835 public void enterRule(ParseTreeListener listener) { 11836 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 11837 } 11838 @Override 11839 public void exitRule(ParseTreeListener listener) { 11840 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 11841 } 11842 @Override 11843 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11844 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 11845 else return visitor.visitChildren(this); 11846 } 11847 } 11848 11849 public final BaseTagContext baseTag() throws RecognitionException { 11850 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 11851 enterRule(_localctx, 108, RULE_baseTag); 11852 int _la; 11853 try { 11854 enterOuterAlt(_localctx, 1); 11855 { 11856 setState(1384); match(OPEN); 11857 setState(1385); match(BASE_HTML_TAG_NAME); 11858 setState(1392); 11859 _errHandler.sync(this); 11860 _la = _input.LA(1); 11861 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11862 { 11863 setState(1390); 11864 switch (_input.LA(1)) { 11865 case HTML_TAG_NAME: 11866 { 11867 setState(1386); attribute(); 11868 } 11869 break; 11870 case NEWLINE: 11871 { 11872 setState(1387); match(NEWLINE); 11873 } 11874 break; 11875 case LEADING_ASTERISK: 11876 { 11877 setState(1388); match(LEADING_ASTERISK); 11878 } 11879 break; 11880 case WS: 11881 { 11882 setState(1389); match(WS); 11883 } 11884 break; 11885 default: 11886 throw new NoViableAltException(this); 11887 } 11888 } 11889 setState(1394); 11890 _errHandler.sync(this); 11891 _la = _input.LA(1); 11892 } 11893 setState(1395); 11894 _la = _input.LA(1); 11895 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 11896 _errHandler.recoverInline(this); 11897 } 11898 consume(); 11899 } 11900 } 11901 catch (RecognitionException re) { 11902 _localctx.exception = re; 11903 _errHandler.reportError(this, re); 11904 _errHandler.recover(this, re); 11905 } 11906 finally { 11907 exitRule(); 11908 } 11909 return _localctx; 11910 } 11911 11912 public static class BasefrontTagContext extends ParserRuleContext { 11913 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11914 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11915 public TerminalNode NEWLINE(int i) { 11916 return getToken(JavadocParser.NEWLINE, i); 11917 } 11918 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11919 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11920 public List<AttributeContext> attribute() { 11921 return getRuleContexts(AttributeContext.class); 11922 } 11923 public AttributeContext attribute(int i) { 11924 return getRuleContext(AttributeContext.class,i); 11925 } 11926 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11927 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11928 public TerminalNode LEADING_ASTERISK(int i) { 11929 return getToken(JavadocParser.LEADING_ASTERISK, i); 11930 } 11931 public TerminalNode WS(int i) { 11932 return getToken(JavadocParser.WS, i); 11933 } 11934 public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); } 11935 public BasefrontTagContext(ParserRuleContext parent, int invokingState) { 11936 super(parent, invokingState); 11937 } 11938 @Override public int getRuleIndex() { return RULE_basefrontTag; } 11939 @Override 11940 public void enterRule(ParseTreeListener listener) { 11941 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefrontTag(this); 11942 } 11943 @Override 11944 public void exitRule(ParseTreeListener listener) { 11945 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefrontTag(this); 11946 } 11947 @Override 11948 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11949 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefrontTag(this); 11950 else return visitor.visitChildren(this); 11951 } 11952 } 11953 11954 public final BasefrontTagContext basefrontTag() throws RecognitionException { 11955 BasefrontTagContext _localctx = new BasefrontTagContext(_ctx, getState()); 11956 enterRule(_localctx, 110, RULE_basefrontTag); 11957 int _la; 11958 try { 11959 enterOuterAlt(_localctx, 1); 11960 { 11961 setState(1397); match(OPEN); 11962 setState(1398); match(BASEFRONT_HTML_TAG_NAME); 11963 setState(1405); 11964 _errHandler.sync(this); 11965 _la = _input.LA(1); 11966 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11967 { 11968 setState(1403); 11969 switch (_input.LA(1)) { 11970 case HTML_TAG_NAME: 11971 { 11972 setState(1399); attribute(); 11973 } 11974 break; 11975 case NEWLINE: 11976 { 11977 setState(1400); match(NEWLINE); 11978 } 11979 break; 11980 case LEADING_ASTERISK: 11981 { 11982 setState(1401); match(LEADING_ASTERISK); 11983 } 11984 break; 11985 case WS: 11986 { 11987 setState(1402); match(WS); 11988 } 11989 break; 11990 default: 11991 throw new NoViableAltException(this); 11992 } 11993 } 11994 setState(1407); 11995 _errHandler.sync(this); 11996 _la = _input.LA(1); 11997 } 11998 setState(1408); 11999 _la = _input.LA(1); 12000 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12001 _errHandler.recoverInline(this); 12002 } 12003 consume(); 12004 } 12005 } 12006 catch (RecognitionException re) { 12007 _localctx.exception = re; 12008 _errHandler.reportError(this, re); 12009 _errHandler.recover(this, re); 12010 } 12011 finally { 12012 exitRule(); 12013 } 12014 return _localctx; 12015 } 12016 12017 public static class BrTagContext extends ParserRuleContext { 12018 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12019 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12020 public TerminalNode NEWLINE(int i) { 12021 return getToken(JavadocParser.NEWLINE, i); 12022 } 12023 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12024 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12025 public List<AttributeContext> attribute() { 12026 return getRuleContexts(AttributeContext.class); 12027 } 12028 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12029 public AttributeContext attribute(int i) { 12030 return getRuleContext(AttributeContext.class,i); 12031 } 12032 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12033 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12034 public TerminalNode LEADING_ASTERISK(int i) { 12035 return getToken(JavadocParser.LEADING_ASTERISK, i); 12036 } 12037 public TerminalNode WS(int i) { 12038 return getToken(JavadocParser.WS, i); 12039 } 12040 public BrTagContext(ParserRuleContext parent, int invokingState) { 12041 super(parent, invokingState); 12042 } 12043 @Override public int getRuleIndex() { return RULE_brTag; } 12044 @Override 12045 public void enterRule(ParseTreeListener listener) { 12046 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12047 } 12048 @Override 12049 public void exitRule(ParseTreeListener listener) { 12050 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12051 } 12052 @Override 12053 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12054 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12055 else return visitor.visitChildren(this); 12056 } 12057 } 12058 12059 public final BrTagContext brTag() throws RecognitionException { 12060 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12061 enterRule(_localctx, 112, RULE_brTag); 12062 int _la; 12063 try { 12064 enterOuterAlt(_localctx, 1); 12065 { 12066 setState(1410); match(OPEN); 12067 setState(1411); match(BR_HTML_TAG_NAME); 12068 setState(1418); 12069 _errHandler.sync(this); 12070 _la = _input.LA(1); 12071 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12072 { 12073 setState(1416); 12074 switch (_input.LA(1)) { 12075 case HTML_TAG_NAME: 12076 { 12077 setState(1412); attribute(); 12078 } 12079 break; 12080 case NEWLINE: 12081 { 12082 setState(1413); match(NEWLINE); 12083 } 12084 break; 12085 case LEADING_ASTERISK: 12086 { 12087 setState(1414); match(LEADING_ASTERISK); 12088 } 12089 break; 12090 case WS: 12091 { 12092 setState(1415); match(WS); 12093 } 12094 break; 12095 default: 12096 throw new NoViableAltException(this); 12097 } 12098 } 12099 setState(1420); 12100 _errHandler.sync(this); 12101 _la = _input.LA(1); 12102 } 12103 setState(1421); 12104 _la = _input.LA(1); 12105 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12106 _errHandler.recoverInline(this); 12107 } 12108 consume(); 12109 } 12110 } 12111 catch (RecognitionException re) { 12112 _localctx.exception = re; 12113 _errHandler.reportError(this, re); 12114 _errHandler.recover(this, re); 12115 } 12116 finally { 12117 exitRule(); 12118 } 12119 return _localctx; 12120 } 12121 12122 public static class ColTagContext extends ParserRuleContext { 12123 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12124 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12125 public TerminalNode NEWLINE(int i) { 12126 return getToken(JavadocParser.NEWLINE, i); 12127 } 12128 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12129 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12130 public List<AttributeContext> attribute() { 12131 return getRuleContexts(AttributeContext.class); 12132 } 12133 public AttributeContext attribute(int i) { 12134 return getRuleContext(AttributeContext.class,i); 12135 } 12136 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12137 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12138 public TerminalNode LEADING_ASTERISK(int i) { 12139 return getToken(JavadocParser.LEADING_ASTERISK, i); 12140 } 12141 public TerminalNode WS(int i) { 12142 return getToken(JavadocParser.WS, i); 12143 } 12144 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12145 public ColTagContext(ParserRuleContext parent, int invokingState) { 12146 super(parent, invokingState); 12147 } 12148 @Override public int getRuleIndex() { return RULE_colTag; } 12149 @Override 12150 public void enterRule(ParseTreeListener listener) { 12151 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12152 } 12153 @Override 12154 public void exitRule(ParseTreeListener listener) { 12155 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12156 } 12157 @Override 12158 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12159 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12160 else return visitor.visitChildren(this); 12161 } 12162 } 12163 12164 public final ColTagContext colTag() throws RecognitionException { 12165 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12166 enterRule(_localctx, 114, RULE_colTag); 12167 int _la; 12168 try { 12169 enterOuterAlt(_localctx, 1); 12170 { 12171 setState(1423); match(OPEN); 12172 setState(1424); match(COL_HTML_TAG_NAME); 12173 setState(1431); 12174 _errHandler.sync(this); 12175 _la = _input.LA(1); 12176 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12177 { 12178 setState(1429); 12179 switch (_input.LA(1)) { 12180 case HTML_TAG_NAME: 12181 { 12182 setState(1425); attribute(); 12183 } 12184 break; 12185 case NEWLINE: 12186 { 12187 setState(1426); match(NEWLINE); 12188 } 12189 break; 12190 case LEADING_ASTERISK: 12191 { 12192 setState(1427); match(LEADING_ASTERISK); 12193 } 12194 break; 12195 case WS: 12196 { 12197 setState(1428); match(WS); 12198 } 12199 break; 12200 default: 12201 throw new NoViableAltException(this); 12202 } 12203 } 12204 setState(1433); 12205 _errHandler.sync(this); 12206 _la = _input.LA(1); 12207 } 12208 setState(1434); 12209 _la = _input.LA(1); 12210 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12211 _errHandler.recoverInline(this); 12212 } 12213 consume(); 12214 } 12215 } 12216 catch (RecognitionException re) { 12217 _localctx.exception = re; 12218 _errHandler.reportError(this, re); 12219 _errHandler.recover(this, re); 12220 } 12221 finally { 12222 exitRule(); 12223 } 12224 return _localctx; 12225 } 12226 12227 public static class FrameTagContext extends ParserRuleContext { 12228 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12229 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12230 public TerminalNode NEWLINE(int i) { 12231 return getToken(JavadocParser.NEWLINE, i); 12232 } 12233 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12234 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12235 public List<AttributeContext> attribute() { 12236 return getRuleContexts(AttributeContext.class); 12237 } 12238 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12239 public AttributeContext attribute(int i) { 12240 return getRuleContext(AttributeContext.class,i); 12241 } 12242 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12243 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12244 public TerminalNode LEADING_ASTERISK(int i) { 12245 return getToken(JavadocParser.LEADING_ASTERISK, i); 12246 } 12247 public TerminalNode WS(int i) { 12248 return getToken(JavadocParser.WS, i); 12249 } 12250 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12251 super(parent, invokingState); 12252 } 12253 @Override public int getRuleIndex() { return RULE_frameTag; } 12254 @Override 12255 public void enterRule(ParseTreeListener listener) { 12256 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12257 } 12258 @Override 12259 public void exitRule(ParseTreeListener listener) { 12260 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12261 } 12262 @Override 12263 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12264 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12265 else return visitor.visitChildren(this); 12266 } 12267 } 12268 12269 public final FrameTagContext frameTag() throws RecognitionException { 12270 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12271 enterRule(_localctx, 116, RULE_frameTag); 12272 int _la; 12273 try { 12274 enterOuterAlt(_localctx, 1); 12275 { 12276 setState(1436); match(OPEN); 12277 setState(1437); match(FRAME_HTML_TAG_NAME); 12278 setState(1444); 12279 _errHandler.sync(this); 12280 _la = _input.LA(1); 12281 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12282 { 12283 setState(1442); 12284 switch (_input.LA(1)) { 12285 case HTML_TAG_NAME: 12286 { 12287 setState(1438); attribute(); 12288 } 12289 break; 12290 case NEWLINE: 12291 { 12292 setState(1439); match(NEWLINE); 12293 } 12294 break; 12295 case LEADING_ASTERISK: 12296 { 12297 setState(1440); match(LEADING_ASTERISK); 12298 } 12299 break; 12300 case WS: 12301 { 12302 setState(1441); match(WS); 12303 } 12304 break; 12305 default: 12306 throw new NoViableAltException(this); 12307 } 12308 } 12309 setState(1446); 12310 _errHandler.sync(this); 12311 _la = _input.LA(1); 12312 } 12313 setState(1447); 12314 _la = _input.LA(1); 12315 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12316 _errHandler.recoverInline(this); 12317 } 12318 consume(); 12319 } 12320 } 12321 catch (RecognitionException re) { 12322 _localctx.exception = re; 12323 _errHandler.reportError(this, re); 12324 _errHandler.recover(this, re); 12325 } 12326 finally { 12327 exitRule(); 12328 } 12329 return _localctx; 12330 } 12331 12332 public static class HrTagContext extends ParserRuleContext { 12333 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12334 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12335 public TerminalNode NEWLINE(int i) { 12336 return getToken(JavadocParser.NEWLINE, i); 12337 } 12338 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12339 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12340 public List<AttributeContext> attribute() { 12341 return getRuleContexts(AttributeContext.class); 12342 } 12343 public AttributeContext attribute(int i) { 12344 return getRuleContext(AttributeContext.class,i); 12345 } 12346 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12347 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12348 public TerminalNode LEADING_ASTERISK(int i) { 12349 return getToken(JavadocParser.LEADING_ASTERISK, i); 12350 } 12351 public TerminalNode WS(int i) { 12352 return getToken(JavadocParser.WS, i); 12353 } 12354 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12355 public HrTagContext(ParserRuleContext parent, int invokingState) { 12356 super(parent, invokingState); 12357 } 12358 @Override public int getRuleIndex() { return RULE_hrTag; } 12359 @Override 12360 public void enterRule(ParseTreeListener listener) { 12361 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12362 } 12363 @Override 12364 public void exitRule(ParseTreeListener listener) { 12365 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12366 } 12367 @Override 12368 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12369 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12370 else return visitor.visitChildren(this); 12371 } 12372 } 12373 12374 public final HrTagContext hrTag() throws RecognitionException { 12375 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12376 enterRule(_localctx, 118, RULE_hrTag); 12377 int _la; 12378 try { 12379 enterOuterAlt(_localctx, 1); 12380 { 12381 setState(1449); match(OPEN); 12382 setState(1450); match(HR_HTML_TAG_NAME); 12383 setState(1457); 12384 _errHandler.sync(this); 12385 _la = _input.LA(1); 12386 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12387 { 12388 setState(1455); 12389 switch (_input.LA(1)) { 12390 case HTML_TAG_NAME: 12391 { 12392 setState(1451); attribute(); 12393 } 12394 break; 12395 case NEWLINE: 12396 { 12397 setState(1452); match(NEWLINE); 12398 } 12399 break; 12400 case LEADING_ASTERISK: 12401 { 12402 setState(1453); match(LEADING_ASTERISK); 12403 } 12404 break; 12405 case WS: 12406 { 12407 setState(1454); match(WS); 12408 } 12409 break; 12410 default: 12411 throw new NoViableAltException(this); 12412 } 12413 } 12414 setState(1459); 12415 _errHandler.sync(this); 12416 _la = _input.LA(1); 12417 } 12418 setState(1460); 12419 _la = _input.LA(1); 12420 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12421 _errHandler.recoverInline(this); 12422 } 12423 consume(); 12424 } 12425 } 12426 catch (RecognitionException re) { 12427 _localctx.exception = re; 12428 _errHandler.reportError(this, re); 12429 _errHandler.recover(this, re); 12430 } 12431 finally { 12432 exitRule(); 12433 } 12434 return _localctx; 12435 } 12436 12437 public static class ImgTagContext extends ParserRuleContext { 12438 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12439 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12440 public TerminalNode NEWLINE(int i) { 12441 return getToken(JavadocParser.NEWLINE, i); 12442 } 12443 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12444 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12445 public List<AttributeContext> attribute() { 12446 return getRuleContexts(AttributeContext.class); 12447 } 12448 public AttributeContext attribute(int i) { 12449 return getRuleContext(AttributeContext.class,i); 12450 } 12451 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12452 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12453 public TerminalNode LEADING_ASTERISK(int i) { 12454 return getToken(JavadocParser.LEADING_ASTERISK, i); 12455 } 12456 public TerminalNode WS(int i) { 12457 return getToken(JavadocParser.WS, i); 12458 } 12459 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12460 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12461 super(parent, invokingState); 12462 } 12463 @Override public int getRuleIndex() { return RULE_imgTag; } 12464 @Override 12465 public void enterRule(ParseTreeListener listener) { 12466 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12467 } 12468 @Override 12469 public void exitRule(ParseTreeListener listener) { 12470 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12471 } 12472 @Override 12473 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12474 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12475 else return visitor.visitChildren(this); 12476 } 12477 } 12478 12479 public final ImgTagContext imgTag() throws RecognitionException { 12480 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12481 enterRule(_localctx, 120, RULE_imgTag); 12482 int _la; 12483 try { 12484 enterOuterAlt(_localctx, 1); 12485 { 12486 setState(1462); match(OPEN); 12487 setState(1463); match(IMG_HTML_TAG_NAME); 12488 setState(1470); 12489 _errHandler.sync(this); 12490 _la = _input.LA(1); 12491 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12492 { 12493 setState(1468); 12494 switch (_input.LA(1)) { 12495 case HTML_TAG_NAME: 12496 { 12497 setState(1464); attribute(); 12498 } 12499 break; 12500 case NEWLINE: 12501 { 12502 setState(1465); match(NEWLINE); 12503 } 12504 break; 12505 case LEADING_ASTERISK: 12506 { 12507 setState(1466); match(LEADING_ASTERISK); 12508 } 12509 break; 12510 case WS: 12511 { 12512 setState(1467); match(WS); 12513 } 12514 break; 12515 default: 12516 throw new NoViableAltException(this); 12517 } 12518 } 12519 setState(1472); 12520 _errHandler.sync(this); 12521 _la = _input.LA(1); 12522 } 12523 setState(1473); 12524 _la = _input.LA(1); 12525 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12526 _errHandler.recoverInline(this); 12527 } 12528 consume(); 12529 } 12530 } 12531 catch (RecognitionException re) { 12532 _localctx.exception = re; 12533 _errHandler.reportError(this, re); 12534 _errHandler.recover(this, re); 12535 } 12536 finally { 12537 exitRule(); 12538 } 12539 return _localctx; 12540 } 12541 12542 public static class InputTagContext extends ParserRuleContext { 12543 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12544 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12545 public TerminalNode NEWLINE(int i) { 12546 return getToken(JavadocParser.NEWLINE, i); 12547 } 12548 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12549 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12550 public List<AttributeContext> attribute() { 12551 return getRuleContexts(AttributeContext.class); 12552 } 12553 public AttributeContext attribute(int i) { 12554 return getRuleContext(AttributeContext.class,i); 12555 } 12556 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12557 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12558 public TerminalNode LEADING_ASTERISK(int i) { 12559 return getToken(JavadocParser.LEADING_ASTERISK, i); 12560 } 12561 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12562 public TerminalNode WS(int i) { 12563 return getToken(JavadocParser.WS, i); 12564 } 12565 public InputTagContext(ParserRuleContext parent, int invokingState) { 12566 super(parent, invokingState); 12567 } 12568 @Override public int getRuleIndex() { return RULE_inputTag; } 12569 @Override 12570 public void enterRule(ParseTreeListener listener) { 12571 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 12572 } 12573 @Override 12574 public void exitRule(ParseTreeListener listener) { 12575 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 12576 } 12577 @Override 12578 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12579 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 12580 else return visitor.visitChildren(this); 12581 } 12582 } 12583 12584 public final InputTagContext inputTag() throws RecognitionException { 12585 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 12586 enterRule(_localctx, 122, RULE_inputTag); 12587 int _la; 12588 try { 12589 enterOuterAlt(_localctx, 1); 12590 { 12591 setState(1475); match(OPEN); 12592 setState(1476); match(INPUT_HTML_TAG_NAME); 12593 setState(1483); 12594 _errHandler.sync(this); 12595 _la = _input.LA(1); 12596 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12597 { 12598 setState(1481); 12599 switch (_input.LA(1)) { 12600 case HTML_TAG_NAME: 12601 { 12602 setState(1477); attribute(); 12603 } 12604 break; 12605 case NEWLINE: 12606 { 12607 setState(1478); match(NEWLINE); 12608 } 12609 break; 12610 case LEADING_ASTERISK: 12611 { 12612 setState(1479); match(LEADING_ASTERISK); 12613 } 12614 break; 12615 case WS: 12616 { 12617 setState(1480); match(WS); 12618 } 12619 break; 12620 default: 12621 throw new NoViableAltException(this); 12622 } 12623 } 12624 setState(1485); 12625 _errHandler.sync(this); 12626 _la = _input.LA(1); 12627 } 12628 setState(1486); 12629 _la = _input.LA(1); 12630 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12631 _errHandler.recoverInline(this); 12632 } 12633 consume(); 12634 } 12635 } 12636 catch (RecognitionException re) { 12637 _localctx.exception = re; 12638 _errHandler.reportError(this, re); 12639 _errHandler.recover(this, re); 12640 } 12641 finally { 12642 exitRule(); 12643 } 12644 return _localctx; 12645 } 12646 12647 public static class IsindexTagContext extends ParserRuleContext { 12648 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12649 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 12650 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12651 public TerminalNode NEWLINE(int i) { 12652 return getToken(JavadocParser.NEWLINE, i); 12653 } 12654 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12655 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12656 public List<AttributeContext> attribute() { 12657 return getRuleContexts(AttributeContext.class); 12658 } 12659 public AttributeContext attribute(int i) { 12660 return getRuleContext(AttributeContext.class,i); 12661 } 12662 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12663 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12664 public TerminalNode LEADING_ASTERISK(int i) { 12665 return getToken(JavadocParser.LEADING_ASTERISK, i); 12666 } 12667 public TerminalNode WS(int i) { 12668 return getToken(JavadocParser.WS, i); 12669 } 12670 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 12671 super(parent, invokingState); 12672 } 12673 @Override public int getRuleIndex() { return RULE_isindexTag; } 12674 @Override 12675 public void enterRule(ParseTreeListener listener) { 12676 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 12677 } 12678 @Override 12679 public void exitRule(ParseTreeListener listener) { 12680 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 12681 } 12682 @Override 12683 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12684 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 12685 else return visitor.visitChildren(this); 12686 } 12687 } 12688 12689 public final IsindexTagContext isindexTag() throws RecognitionException { 12690 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 12691 enterRule(_localctx, 124, RULE_isindexTag); 12692 int _la; 12693 try { 12694 enterOuterAlt(_localctx, 1); 12695 { 12696 setState(1488); match(OPEN); 12697 setState(1489); match(ISINDEX_HTML_TAG_NAME); 12698 setState(1496); 12699 _errHandler.sync(this); 12700 _la = _input.LA(1); 12701 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12702 { 12703 setState(1494); 12704 switch (_input.LA(1)) { 12705 case HTML_TAG_NAME: 12706 { 12707 setState(1490); attribute(); 12708 } 12709 break; 12710 case NEWLINE: 12711 { 12712 setState(1491); match(NEWLINE); 12713 } 12714 break; 12715 case LEADING_ASTERISK: 12716 { 12717 setState(1492); match(LEADING_ASTERISK); 12718 } 12719 break; 12720 case WS: 12721 { 12722 setState(1493); match(WS); 12723 } 12724 break; 12725 default: 12726 throw new NoViableAltException(this); 12727 } 12728 } 12729 setState(1498); 12730 _errHandler.sync(this); 12731 _la = _input.LA(1); 12732 } 12733 setState(1499); 12734 _la = _input.LA(1); 12735 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12736 _errHandler.recoverInline(this); 12737 } 12738 consume(); 12739 } 12740 } 12741 catch (RecognitionException re) { 12742 _localctx.exception = re; 12743 _errHandler.reportError(this, re); 12744 _errHandler.recover(this, re); 12745 } 12746 finally { 12747 exitRule(); 12748 } 12749 return _localctx; 12750 } 12751 12752 public static class LinkTagContext extends ParserRuleContext { 12753 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12754 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12755 public TerminalNode NEWLINE(int i) { 12756 return getToken(JavadocParser.NEWLINE, i); 12757 } 12758 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12759 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12760 public List<AttributeContext> attribute() { 12761 return getRuleContexts(AttributeContext.class); 12762 } 12763 public AttributeContext attribute(int i) { 12764 return getRuleContext(AttributeContext.class,i); 12765 } 12766 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12767 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12768 public TerminalNode LEADING_ASTERISK(int i) { 12769 return getToken(JavadocParser.LEADING_ASTERISK, i); 12770 } 12771 public TerminalNode WS(int i) { 12772 return getToken(JavadocParser.WS, i); 12773 } 12774 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 12775 public LinkTagContext(ParserRuleContext parent, int invokingState) { 12776 super(parent, invokingState); 12777 } 12778 @Override public int getRuleIndex() { return RULE_linkTag; } 12779 @Override 12780 public void enterRule(ParseTreeListener listener) { 12781 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 12782 } 12783 @Override 12784 public void exitRule(ParseTreeListener listener) { 12785 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 12786 } 12787 @Override 12788 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12789 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 12790 else return visitor.visitChildren(this); 12791 } 12792 } 12793 12794 public final LinkTagContext linkTag() throws RecognitionException { 12795 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 12796 enterRule(_localctx, 126, RULE_linkTag); 12797 int _la; 12798 try { 12799 enterOuterAlt(_localctx, 1); 12800 { 12801 setState(1501); match(OPEN); 12802 setState(1502); match(LINK_HTML_TAG_NAME); 12803 setState(1509); 12804 _errHandler.sync(this); 12805 _la = _input.LA(1); 12806 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12807 { 12808 setState(1507); 12809 switch (_input.LA(1)) { 12810 case HTML_TAG_NAME: 12811 { 12812 setState(1503); attribute(); 12813 } 12814 break; 12815 case NEWLINE: 12816 { 12817 setState(1504); match(NEWLINE); 12818 } 12819 break; 12820 case LEADING_ASTERISK: 12821 { 12822 setState(1505); match(LEADING_ASTERISK); 12823 } 12824 break; 12825 case WS: 12826 { 12827 setState(1506); match(WS); 12828 } 12829 break; 12830 default: 12831 throw new NoViableAltException(this); 12832 } 12833 } 12834 setState(1511); 12835 _errHandler.sync(this); 12836 _la = _input.LA(1); 12837 } 12838 setState(1512); 12839 _la = _input.LA(1); 12840 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12841 _errHandler.recoverInline(this); 12842 } 12843 consume(); 12844 } 12845 } 12846 catch (RecognitionException re) { 12847 _localctx.exception = re; 12848 _errHandler.reportError(this, re); 12849 _errHandler.recover(this, re); 12850 } 12851 finally { 12852 exitRule(); 12853 } 12854 return _localctx; 12855 } 12856 12857 public static class MetaTagContext extends ParserRuleContext { 12858 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12859 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12860 public TerminalNode NEWLINE(int i) { 12861 return getToken(JavadocParser.NEWLINE, i); 12862 } 12863 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12864 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12865 public List<AttributeContext> attribute() { 12866 return getRuleContexts(AttributeContext.class); 12867 } 12868 public AttributeContext attribute(int i) { 12869 return getRuleContext(AttributeContext.class,i); 12870 } 12871 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12872 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12873 public TerminalNode LEADING_ASTERISK(int i) { 12874 return getToken(JavadocParser.LEADING_ASTERISK, i); 12875 } 12876 public TerminalNode WS(int i) { 12877 return getToken(JavadocParser.WS, i); 12878 } 12879 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 12880 public MetaTagContext(ParserRuleContext parent, int invokingState) { 12881 super(parent, invokingState); 12882 } 12883 @Override public int getRuleIndex() { return RULE_metaTag; } 12884 @Override 12885 public void enterRule(ParseTreeListener listener) { 12886 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 12887 } 12888 @Override 12889 public void exitRule(ParseTreeListener listener) { 12890 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 12891 } 12892 @Override 12893 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12894 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 12895 else return visitor.visitChildren(this); 12896 } 12897 } 12898 12899 public final MetaTagContext metaTag() throws RecognitionException { 12900 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 12901 enterRule(_localctx, 128, RULE_metaTag); 12902 int _la; 12903 try { 12904 enterOuterAlt(_localctx, 1); 12905 { 12906 setState(1514); match(OPEN); 12907 setState(1515); match(META_HTML_TAG_NAME); 12908 setState(1522); 12909 _errHandler.sync(this); 12910 _la = _input.LA(1); 12911 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12912 { 12913 setState(1520); 12914 switch (_input.LA(1)) { 12915 case HTML_TAG_NAME: 12916 { 12917 setState(1516); attribute(); 12918 } 12919 break; 12920 case NEWLINE: 12921 { 12922 setState(1517); match(NEWLINE); 12923 } 12924 break; 12925 case LEADING_ASTERISK: 12926 { 12927 setState(1518); match(LEADING_ASTERISK); 12928 } 12929 break; 12930 case WS: 12931 { 12932 setState(1519); match(WS); 12933 } 12934 break; 12935 default: 12936 throw new NoViableAltException(this); 12937 } 12938 } 12939 setState(1524); 12940 _errHandler.sync(this); 12941 _la = _input.LA(1); 12942 } 12943 setState(1525); 12944 _la = _input.LA(1); 12945 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12946 _errHandler.recoverInline(this); 12947 } 12948 consume(); 12949 } 12950 } 12951 catch (RecognitionException re) { 12952 _localctx.exception = re; 12953 _errHandler.reportError(this, re); 12954 _errHandler.recover(this, re); 12955 } 12956 finally { 12957 exitRule(); 12958 } 12959 return _localctx; 12960 } 12961 12962 public static class ParamTagContext extends ParserRuleContext { 12963 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12964 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12965 public TerminalNode NEWLINE(int i) { 12966 return getToken(JavadocParser.NEWLINE, i); 12967 } 12968 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12969 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12970 public List<AttributeContext> attribute() { 12971 return getRuleContexts(AttributeContext.class); 12972 } 12973 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 12974 public AttributeContext attribute(int i) { 12975 return getRuleContext(AttributeContext.class,i); 12976 } 12977 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12978 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12979 public TerminalNode LEADING_ASTERISK(int i) { 12980 return getToken(JavadocParser.LEADING_ASTERISK, i); 12981 } 12982 public TerminalNode WS(int i) { 12983 return getToken(JavadocParser.WS, i); 12984 } 12985 public ParamTagContext(ParserRuleContext parent, int invokingState) { 12986 super(parent, invokingState); 12987 } 12988 @Override public int getRuleIndex() { return RULE_paramTag; } 12989 @Override 12990 public void enterRule(ParseTreeListener listener) { 12991 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 12992 } 12993 @Override 12994 public void exitRule(ParseTreeListener listener) { 12995 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 12996 } 12997 @Override 12998 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12999 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13000 else return visitor.visitChildren(this); 13001 } 13002 } 13003 13004 public final ParamTagContext paramTag() throws RecognitionException { 13005 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13006 enterRule(_localctx, 130, RULE_paramTag); 13007 int _la; 13008 try { 13009 enterOuterAlt(_localctx, 1); 13010 { 13011 setState(1527); match(OPEN); 13012 setState(1528); match(PARAM_HTML_TAG_NAME); 13013 setState(1535); 13014 _errHandler.sync(this); 13015 _la = _input.LA(1); 13016 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13017 { 13018 setState(1533); 13019 switch (_input.LA(1)) { 13020 case HTML_TAG_NAME: 13021 { 13022 setState(1529); attribute(); 13023 } 13024 break; 13025 case NEWLINE: 13026 { 13027 setState(1530); match(NEWLINE); 13028 } 13029 break; 13030 case LEADING_ASTERISK: 13031 { 13032 setState(1531); match(LEADING_ASTERISK); 13033 } 13034 break; 13035 case WS: 13036 { 13037 setState(1532); match(WS); 13038 } 13039 break; 13040 default: 13041 throw new NoViableAltException(this); 13042 } 13043 } 13044 setState(1537); 13045 _errHandler.sync(this); 13046 _la = _input.LA(1); 13047 } 13048 setState(1538); 13049 _la = _input.LA(1); 13050 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13051 _errHandler.recoverInline(this); 13052 } 13053 consume(); 13054 } 13055 } 13056 catch (RecognitionException re) { 13057 _localctx.exception = re; 13058 _errHandler.reportError(this, re); 13059 _errHandler.recover(this, re); 13060 } 13061 finally { 13062 exitRule(); 13063 } 13064 return _localctx; 13065 } 13066 13067 public static class WrongSinletonTagContext extends ParserRuleContext { 13068 public SingletonTagNameContext singletonTagName; 13069 public SingletonTagNameContext singletonTagName() { 13070 return getRuleContext(SingletonTagNameContext.class,0); 13071 } 13072 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13073 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13074 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13075 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13076 super(parent, invokingState); 13077 } 13078 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13079 @Override 13080 public void enterRule(ParseTreeListener listener) { 13081 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13082 } 13083 @Override 13084 public void exitRule(ParseTreeListener listener) { 13085 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13086 } 13087 @Override 13088 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13089 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13090 else return visitor.visitChildren(this); 13091 } 13092 } 13093 13094 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13095 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13096 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13097 try { 13098 enterOuterAlt(_localctx, 1); 13099 { 13100 setState(1540); match(OPEN); 13101 setState(1541); match(SLASH); 13102 setState(1542); ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13103 setState(1543); match(CLOSE); 13104 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), "javadoc.wrong.singleton.html.tag", null); 13105 } 13106 } 13107 catch (RecognitionException re) { 13108 _localctx.exception = re; 13109 _errHandler.reportError(this, re); 13110 _errHandler.recover(this, re); 13111 } 13112 finally { 13113 exitRule(); 13114 } 13115 return _localctx; 13116 } 13117 13118 public static class SingletonTagNameContext extends ParserRuleContext { 13119 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13120 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13121 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13122 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13123 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13124 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13125 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13126 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13127 public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); } 13128 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13129 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13130 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13131 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13132 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13133 super(parent, invokingState); 13134 } 13135 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13136 @Override 13137 public void enterRule(ParseTreeListener listener) { 13138 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13139 } 13140 @Override 13141 public void exitRule(ParseTreeListener listener) { 13142 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13143 } 13144 @Override 13145 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13146 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13147 else return visitor.visitChildren(this); 13148 } 13149 } 13150 13151 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13152 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13153 enterRule(_localctx, 134, RULE_singletonTagName); 13154 int _la; 13155 try { 13156 enterOuterAlt(_localctx, 1); 13157 { 13158 setState(1546); 13159 _la = _input.LA(1); 13160 if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFRONT_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)) ) { 13161 _errHandler.recoverInline(this); 13162 } 13163 consume(); 13164 } 13165 } 13166 catch (RecognitionException re) { 13167 _localctx.exception = re; 13168 _errHandler.reportError(this, re); 13169 _errHandler.recover(this, re); 13170 } 13171 finally { 13172 exitRule(); 13173 } 13174 return _localctx; 13175 } 13176 13177 public static class DescriptionContext extends ParserRuleContext { 13178 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13179 public TerminalNode NEWLINE(int i) { 13180 return getToken(JavadocParser.NEWLINE, i); 13181 } 13182 public TextContext text(int i) { 13183 return getRuleContext(TextContext.class,i); 13184 } 13185 public List<JavadocInlineTagContext> javadocInlineTag() { 13186 return getRuleContexts(JavadocInlineTagContext.class); 13187 } 13188 public List<HtmlElementContext> htmlElement() { 13189 return getRuleContexts(HtmlElementContext.class); 13190 } 13191 public List<HtmlCommentContext> htmlComment() { 13192 return getRuleContexts(HtmlCommentContext.class); 13193 } 13194 public TerminalNode CDATA(int i) { 13195 return getToken(JavadocParser.CDATA, i); 13196 } 13197 public HtmlCommentContext htmlComment(int i) { 13198 return getRuleContext(HtmlCommentContext.class,i); 13199 } 13200 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13201 public List<TextContext> text() { 13202 return getRuleContexts(TextContext.class); 13203 } 13204 public HtmlElementContext htmlElement(int i) { 13205 return getRuleContext(HtmlElementContext.class,i); 13206 } 13207 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13208 public JavadocInlineTagContext javadocInlineTag(int i) { 13209 return getRuleContext(JavadocInlineTagContext.class,i); 13210 } 13211 public TerminalNode LEADING_ASTERISK(int i) { 13212 return getToken(JavadocParser.LEADING_ASTERISK, i); 13213 } 13214 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13215 super(parent, invokingState); 13216 } 13217 @Override public int getRuleIndex() { return RULE_description; } 13218 @Override 13219 public void enterRule(ParseTreeListener listener) { 13220 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13221 } 13222 @Override 13223 public void exitRule(ParseTreeListener listener) { 13224 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13225 } 13226 @Override 13227 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13228 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13229 else return visitor.visitChildren(this); 13230 } 13231 } 13232 13233 public final DescriptionContext description() throws RecognitionException { 13234 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13235 enterRule(_localctx, 136, RULE_description); 13236 try { 13237 int _alt; 13238 enterOuterAlt(_localctx, 1); 13239 { 13240 setState(1556); 13241 _errHandler.sync(this); 13242 _alt = 1; 13243 do { 13244 switch (_alt) { 13245 case 1: 13246 { 13247 setState(1556); 13248 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13249 case 1: 13250 { 13251 { 13252 setState(1548); 13253 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13254 setState(1549); match(LEADING_ASTERISK); 13255 } 13256 } 13257 break; 13258 13259 case 2: 13260 { 13261 setState(1550); htmlComment(); 13262 } 13263 break; 13264 13265 case 3: 13266 { 13267 setState(1551); match(CDATA); 13268 } 13269 break; 13270 13271 case 4: 13272 { 13273 setState(1552); match(NEWLINE); 13274 } 13275 break; 13276 13277 case 5: 13278 { 13279 setState(1553); text(); 13280 } 13281 break; 13282 13283 case 6: 13284 { 13285 setState(1554); javadocInlineTag(); 13286 } 13287 break; 13288 13289 case 7: 13290 { 13291 setState(1555); htmlElement(); 13292 } 13293 break; 13294 } 13295 } 13296 break; 13297 default: 13298 throw new NoViableAltException(this); 13299 } 13300 setState(1558); 13301 _errHandler.sync(this); 13302 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13303 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13304 } 13305 } 13306 catch (RecognitionException re) { 13307 _localctx.exception = re; 13308 _errHandler.reportError(this, re); 13309 _errHandler.recover(this, re); 13310 } 13311 finally { 13312 exitRule(); 13313 } 13314 return _localctx; 13315 } 13316 13317 public static class ReferenceContext extends ParserRuleContext { 13318 public TerminalNode CLASS(int i) { 13319 return getToken(JavadocParser.CLASS, i); 13320 } 13321 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13322 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13323 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13324 public ParametersContext parameters() { 13325 return getRuleContext(ParametersContext.class,0); 13326 } 13327 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13328 public TerminalNode DOT(int i) { 13329 return getToken(JavadocParser.DOT, i); 13330 } 13331 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13332 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13333 super(parent, invokingState); 13334 } 13335 @Override public int getRuleIndex() { return RULE_reference; } 13336 @Override 13337 public void enterRule(ParseTreeListener listener) { 13338 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13339 } 13340 @Override 13341 public void exitRule(ParseTreeListener listener) { 13342 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13343 } 13344 @Override 13345 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13346 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13347 else return visitor.visitChildren(this); 13348 } 13349 } 13350 13351 public final ReferenceContext reference() throws RecognitionException { 13352 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13353 enterRule(_localctx, 138, RULE_reference); 13354 int _la; 13355 try { 13356 int _alt; 13357 enterOuterAlt(_localctx, 1); 13358 { 13359 setState(1597); 13360 switch (_input.LA(1)) { 13361 case PACKAGE: 13362 { 13363 setState(1560); match(PACKAGE); 13364 setState(1564); 13365 _errHandler.sync(this); 13366 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13367 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13368 if ( _alt==1 ) { 13369 { 13370 { 13371 setState(1561); 13372 _la = _input.LA(1); 13373 if ( !(_la==DOT || _la==CLASS) ) { 13374 _errHandler.recoverInline(this); 13375 } 13376 consume(); 13377 } 13378 } 13379 } 13380 setState(1566); 13381 _errHandler.sync(this); 13382 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13383 } 13384 setState(1568); 13385 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13386 case 1: 13387 { 13388 setState(1567); match(HASH); 13389 } 13390 break; 13391 } 13392 setState(1571); 13393 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13394 case 1: 13395 { 13396 setState(1570); match(MEMBER); 13397 } 13398 break; 13399 } 13400 setState(1574); 13401 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13402 case 1: 13403 { 13404 setState(1573); parameters(); 13405 } 13406 break; 13407 } 13408 } 13409 break; 13410 case DOT: 13411 case CLASS: 13412 { 13413 setState(1577); 13414 _errHandler.sync(this); 13415 _alt = 1; 13416 do { 13417 switch (_alt) { 13418 case 1: 13419 { 13420 { 13421 setState(1576); 13422 _la = _input.LA(1); 13423 if ( !(_la==DOT || _la==CLASS) ) { 13424 _errHandler.recoverInline(this); 13425 } 13426 consume(); 13427 } 13428 } 13429 break; 13430 default: 13431 throw new NoViableAltException(this); 13432 } 13433 setState(1579); 13434 _errHandler.sync(this); 13435 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 13436 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13437 setState(1582); 13438 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 13439 case 1: 13440 { 13441 setState(1581); match(HASH); 13442 } 13443 break; 13444 } 13445 setState(1585); 13446 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 13447 case 1: 13448 { 13449 setState(1584); match(MEMBER); 13450 } 13451 break; 13452 } 13453 setState(1588); 13454 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 13455 case 1: 13456 { 13457 setState(1587); parameters(); 13458 } 13459 break; 13460 } 13461 } 13462 break; 13463 case HASH: 13464 case MEMBER: 13465 { 13466 setState(1591); 13467 _la = _input.LA(1); 13468 if (_la==HASH) { 13469 { 13470 setState(1590); match(HASH); 13471 } 13472 } 13473 13474 setState(1593); match(MEMBER); 13475 setState(1595); 13476 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 13477 case 1: 13478 { 13479 setState(1594); parameters(); 13480 } 13481 break; 13482 } 13483 } 13484 break; 13485 default: 13486 throw new NoViableAltException(this); 13487 } 13488 } 13489 } 13490 catch (RecognitionException re) { 13491 _localctx.exception = re; 13492 _errHandler.reportError(this, re); 13493 _errHandler.recover(this, re); 13494 } 13495 finally { 13496 exitRule(); 13497 } 13498 return _localctx; 13499 } 13500 13501 public static class ParametersContext extends ParserRuleContext { 13502 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13503 public TerminalNode ARGUMENT(int i) { 13504 return getToken(JavadocParser.ARGUMENT, i); 13505 } 13506 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 13507 public TerminalNode NEWLINE(int i) { 13508 return getToken(JavadocParser.NEWLINE, i); 13509 } 13510 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13511 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13512 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 13513 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 13514 public TerminalNode LEADING_ASTERISK(int i) { 13515 return getToken(JavadocParser.LEADING_ASTERISK, i); 13516 } 13517 public TerminalNode WS(int i) { 13518 return getToken(JavadocParser.WS, i); 13519 } 13520 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 13521 public TerminalNode COMMA(int i) { 13522 return getToken(JavadocParser.COMMA, i); 13523 } 13524 public ParametersContext(ParserRuleContext parent, int invokingState) { 13525 super(parent, invokingState); 13526 } 13527 @Override public int getRuleIndex() { return RULE_parameters; } 13528 @Override 13529 public void enterRule(ParseTreeListener listener) { 13530 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 13531 } 13532 @Override 13533 public void exitRule(ParseTreeListener listener) { 13534 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 13535 } 13536 @Override 13537 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13538 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 13539 else return visitor.visitChildren(this); 13540 } 13541 } 13542 13543 public final ParametersContext parameters() throws RecognitionException { 13544 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 13545 enterRule(_localctx, 140, RULE_parameters); 13546 int _la; 13547 try { 13548 enterOuterAlt(_localctx, 1); 13549 { 13550 setState(1599); match(LEFT_BRACE); 13551 setState(1603); 13552 _errHandler.sync(this); 13553 _la = _input.LA(1); 13554 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 13555 { 13556 { 13557 setState(1600); 13558 _la = _input.LA(1); 13559 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 13560 _errHandler.recoverInline(this); 13561 } 13562 consume(); 13563 } 13564 } 13565 setState(1605); 13566 _errHandler.sync(this); 13567 _la = _input.LA(1); 13568 } 13569 setState(1606); match(RIGHT_BRACE); 13570 } 13571 } 13572 catch (RecognitionException re) { 13573 _localctx.exception = re; 13574 _errHandler.reportError(this, re); 13575 _errHandler.recover(this, re); 13576 } 13577 finally { 13578 exitRule(); 13579 } 13580 return _localctx; 13581 } 13582 13583 public static class JavadocTagContext extends ParserRuleContext { 13584 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 13585 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 13586 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 13587 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 13588 public TerminalNode STRING(int i) { 13589 return getToken(JavadocParser.STRING, i); 13590 } 13591 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13592 public List<HtmlElementContext> htmlElement() { 13593 return getRuleContexts(HtmlElementContext.class); 13594 } 13595 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 13596 public TerminalNode WS(int i) { 13597 return getToken(JavadocParser.WS, i); 13598 } 13599 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 13600 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 13601 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 13602 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 13603 public TerminalNode NEWLINE(int i) { 13604 return getToken(JavadocParser.NEWLINE, i); 13605 } 13606 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 13607 public DescriptionContext description() { 13608 return getRuleContext(DescriptionContext.class,0); 13609 } 13610 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 13611 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 13612 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 13613 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 13614 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13615 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 13616 public HtmlElementContext htmlElement(int i) { 13617 return getRuleContext(HtmlElementContext.class,i); 13618 } 13619 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 13620 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 13621 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 13622 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 13623 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 13624 public ReferenceContext reference() { 13625 return getRuleContext(ReferenceContext.class,0); 13626 } 13627 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 13628 super(parent, invokingState); 13629 } 13630 @Override public int getRuleIndex() { return RULE_javadocTag; } 13631 @Override 13632 public void enterRule(ParseTreeListener listener) { 13633 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 13634 } 13635 @Override 13636 public void exitRule(ParseTreeListener listener) { 13637 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 13638 } 13639 @Override 13640 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13641 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 13642 else return visitor.visitChildren(this); 13643 } 13644 } 13645 13646 public final JavadocTagContext javadocTag() throws RecognitionException { 13647 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 13648 enterRule(_localctx, 142, RULE_javadocTag); 13649 int _la; 13650 try { 13651 int _alt; 13652 setState(1802); 13653 switch (_input.LA(1)) { 13654 case AUTHOR_LITERAL: 13655 enterOuterAlt(_localctx, 1); 13656 { 13657 setState(1608); match(AUTHOR_LITERAL); 13658 setState(1612); 13659 _errHandler.sync(this); 13660 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 13661 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13662 if ( _alt==1 ) { 13663 { 13664 { 13665 setState(1609); 13666 _la = _input.LA(1); 13667 if ( !(_la==WS || _la==NEWLINE) ) { 13668 _errHandler.recoverInline(this); 13669 } 13670 consume(); 13671 } 13672 } 13673 } 13674 setState(1614); 13675 _errHandler.sync(this); 13676 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 13677 } 13678 setState(1616); 13679 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 13680 case 1: 13681 { 13682 setState(1615); description(); 13683 } 13684 break; 13685 } 13686 } 13687 break; 13688 case DEPRECATED_LITERAL: 13689 enterOuterAlt(_localctx, 2); 13690 { 13691 setState(1618); match(DEPRECATED_LITERAL); 13692 setState(1622); 13693 _errHandler.sync(this); 13694 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 13695 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13696 if ( _alt==1 ) { 13697 { 13698 { 13699 setState(1619); 13700 _la = _input.LA(1); 13701 if ( !(_la==WS || _la==NEWLINE) ) { 13702 _errHandler.recoverInline(this); 13703 } 13704 consume(); 13705 } 13706 } 13707 } 13708 setState(1624); 13709 _errHandler.sync(this); 13710 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 13711 } 13712 setState(1626); 13713 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 13714 case 1: 13715 { 13716 setState(1625); description(); 13717 } 13718 break; 13719 } 13720 } 13721 break; 13722 case EXCEPTION_LITERAL: 13723 enterOuterAlt(_localctx, 3); 13724 { 13725 setState(1628); match(EXCEPTION_LITERAL); 13726 setState(1632); 13727 _errHandler.sync(this); 13728 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 13729 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13730 if ( _alt==1 ) { 13731 { 13732 { 13733 setState(1629); 13734 _la = _input.LA(1); 13735 if ( !(_la==WS || _la==NEWLINE) ) { 13736 _errHandler.recoverInline(this); 13737 } 13738 consume(); 13739 } 13740 } 13741 } 13742 setState(1634); 13743 _errHandler.sync(this); 13744 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 13745 } 13746 setState(1636); 13747 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 13748 case 1: 13749 { 13750 setState(1635); match(CLASS_NAME); 13751 } 13752 break; 13753 } 13754 setState(1641); 13755 _errHandler.sync(this); 13756 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 13757 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13758 if ( _alt==1 ) { 13759 { 13760 { 13761 setState(1638); 13762 _la = _input.LA(1); 13763 if ( !(_la==WS || _la==NEWLINE) ) { 13764 _errHandler.recoverInline(this); 13765 } 13766 consume(); 13767 } 13768 } 13769 } 13770 setState(1643); 13771 _errHandler.sync(this); 13772 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 13773 } 13774 setState(1645); 13775 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 13776 case 1: 13777 { 13778 setState(1644); description(); 13779 } 13780 break; 13781 } 13782 } 13783 break; 13784 case PARAM_LITERAL: 13785 enterOuterAlt(_localctx, 4); 13786 { 13787 setState(1647); match(PARAM_LITERAL); 13788 setState(1651); 13789 _errHandler.sync(this); 13790 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 13791 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13792 if ( _alt==1 ) { 13793 { 13794 { 13795 setState(1648); 13796 _la = _input.LA(1); 13797 if ( !(_la==WS || _la==NEWLINE) ) { 13798 _errHandler.recoverInline(this); 13799 } 13800 consume(); 13801 } 13802 } 13803 } 13804 setState(1653); 13805 _errHandler.sync(this); 13806 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 13807 } 13808 setState(1655); 13809 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 13810 case 1: 13811 { 13812 setState(1654); match(PARAMETER_NAME); 13813 } 13814 break; 13815 } 13816 setState(1660); 13817 _errHandler.sync(this); 13818 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 13819 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13820 if ( _alt==1 ) { 13821 { 13822 { 13823 setState(1657); 13824 _la = _input.LA(1); 13825 if ( !(_la==WS || _la==NEWLINE) ) { 13826 _errHandler.recoverInline(this); 13827 } 13828 consume(); 13829 } 13830 } 13831 } 13832 setState(1662); 13833 _errHandler.sync(this); 13834 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 13835 } 13836 setState(1664); 13837 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 13838 case 1: 13839 { 13840 setState(1663); description(); 13841 } 13842 break; 13843 } 13844 } 13845 break; 13846 case RETURN_LITERAL: 13847 enterOuterAlt(_localctx, 5); 13848 { 13849 setState(1666); match(RETURN_LITERAL); 13850 setState(1670); 13851 _errHandler.sync(this); 13852 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 13853 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13854 if ( _alt==1 ) { 13855 { 13856 { 13857 setState(1667); 13858 _la = _input.LA(1); 13859 if ( !(_la==WS || _la==NEWLINE) ) { 13860 _errHandler.recoverInline(this); 13861 } 13862 consume(); 13863 } 13864 } 13865 } 13866 setState(1672); 13867 _errHandler.sync(this); 13868 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 13869 } 13870 setState(1674); 13871 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 13872 case 1: 13873 { 13874 setState(1673); description(); 13875 } 13876 break; 13877 } 13878 } 13879 break; 13880 case SEE_LITERAL: 13881 enterOuterAlt(_localctx, 6); 13882 { 13883 setState(1676); match(SEE_LITERAL); 13884 setState(1680); 13885 _errHandler.sync(this); 13886 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 13887 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13888 if ( _alt==1 ) { 13889 { 13890 { 13891 setState(1677); 13892 _la = _input.LA(1); 13893 if ( !(_la==WS || _la==NEWLINE) ) { 13894 _errHandler.recoverInline(this); 13895 } 13896 consume(); 13897 } 13898 } 13899 } 13900 setState(1682); 13901 _errHandler.sync(this); 13902 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 13903 } 13904 setState(1684); 13905 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 13906 case 1: 13907 { 13908 setState(1683); reference(); 13909 } 13910 break; 13911 } 13912 setState(1690); 13913 _errHandler.sync(this); 13914 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 13915 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13916 if ( _alt==1 ) { 13917 { 13918 setState(1688); 13919 switch (_input.LA(1)) { 13920 case STRING: 13921 { 13922 setState(1686); match(STRING); 13923 } 13924 break; 13925 case OPEN: 13926 { 13927 setState(1687); htmlElement(); 13928 } 13929 break; 13930 default: 13931 throw new NoViableAltException(this); 13932 } 13933 } 13934 } 13935 setState(1692); 13936 _errHandler.sync(this); 13937 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 13938 } 13939 setState(1696); 13940 _errHandler.sync(this); 13941 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 13942 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13943 if ( _alt==1 ) { 13944 { 13945 { 13946 setState(1693); 13947 _la = _input.LA(1); 13948 if ( !(_la==WS || _la==NEWLINE) ) { 13949 _errHandler.recoverInline(this); 13950 } 13951 consume(); 13952 } 13953 } 13954 } 13955 setState(1698); 13956 _errHandler.sync(this); 13957 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 13958 } 13959 setState(1700); 13960 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 13961 case 1: 13962 { 13963 setState(1699); description(); 13964 } 13965 break; 13966 } 13967 } 13968 break; 13969 case SERIAL_LITERAL: 13970 enterOuterAlt(_localctx, 7); 13971 { 13972 setState(1702); match(SERIAL_LITERAL); 13973 setState(1706); 13974 _errHandler.sync(this); 13975 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 13976 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13977 if ( _alt==1 ) { 13978 { 13979 { 13980 setState(1703); 13981 _la = _input.LA(1); 13982 if ( !(_la==WS || _la==NEWLINE) ) { 13983 _errHandler.recoverInline(this); 13984 } 13985 consume(); 13986 } 13987 } 13988 } 13989 setState(1708); 13990 _errHandler.sync(this); 13991 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 13992 } 13993 setState(1710); 13994 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 13995 case 1: 13996 { 13997 setState(1709); 13998 _la = _input.LA(1); 13999 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14000 _errHandler.recoverInline(this); 14001 } 14002 consume(); 14003 } 14004 break; 14005 } 14006 setState(1713); 14007 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14008 case 1: 14009 { 14010 setState(1712); description(); 14011 } 14012 break; 14013 } 14014 } 14015 break; 14016 case SERIAL_DATA_LITERAL: 14017 enterOuterAlt(_localctx, 8); 14018 { 14019 setState(1715); match(SERIAL_DATA_LITERAL); 14020 setState(1719); 14021 _errHandler.sync(this); 14022 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14023 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14024 if ( _alt==1 ) { 14025 { 14026 { 14027 setState(1716); 14028 _la = _input.LA(1); 14029 if ( !(_la==WS || _la==NEWLINE) ) { 14030 _errHandler.recoverInline(this); 14031 } 14032 consume(); 14033 } 14034 } 14035 } 14036 setState(1721); 14037 _errHandler.sync(this); 14038 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14039 } 14040 setState(1723); 14041 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14042 case 1: 14043 { 14044 setState(1722); description(); 14045 } 14046 break; 14047 } 14048 } 14049 break; 14050 case SERIAL_FIELD_LITERAL: 14051 enterOuterAlt(_localctx, 9); 14052 { 14053 setState(1725); match(SERIAL_FIELD_LITERAL); 14054 setState(1729); 14055 _errHandler.sync(this); 14056 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14057 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14058 if ( _alt==1 ) { 14059 { 14060 { 14061 setState(1726); 14062 _la = _input.LA(1); 14063 if ( !(_la==WS || _la==NEWLINE) ) { 14064 _errHandler.recoverInline(this); 14065 } 14066 consume(); 14067 } 14068 } 14069 } 14070 setState(1731); 14071 _errHandler.sync(this); 14072 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14073 } 14074 setState(1733); 14075 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14076 case 1: 14077 { 14078 setState(1732); match(FIELD_NAME); 14079 } 14080 break; 14081 } 14082 setState(1738); 14083 _errHandler.sync(this); 14084 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14085 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14086 if ( _alt==1 ) { 14087 { 14088 { 14089 setState(1735); 14090 _la = _input.LA(1); 14091 if ( !(_la==WS || _la==NEWLINE) ) { 14092 _errHandler.recoverInline(this); 14093 } 14094 consume(); 14095 } 14096 } 14097 } 14098 setState(1740); 14099 _errHandler.sync(this); 14100 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14101 } 14102 setState(1742); 14103 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14104 case 1: 14105 { 14106 setState(1741); match(FIELD_TYPE); 14107 } 14108 break; 14109 } 14110 setState(1747); 14111 _errHandler.sync(this); 14112 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14113 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14114 if ( _alt==1 ) { 14115 { 14116 { 14117 setState(1744); 14118 _la = _input.LA(1); 14119 if ( !(_la==WS || _la==NEWLINE) ) { 14120 _errHandler.recoverInline(this); 14121 } 14122 consume(); 14123 } 14124 } 14125 } 14126 setState(1749); 14127 _errHandler.sync(this); 14128 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14129 } 14130 setState(1751); 14131 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14132 case 1: 14133 { 14134 setState(1750); description(); 14135 } 14136 break; 14137 } 14138 } 14139 break; 14140 case SINCE_LITERAL: 14141 enterOuterAlt(_localctx, 10); 14142 { 14143 setState(1753); match(SINCE_LITERAL); 14144 setState(1757); 14145 _errHandler.sync(this); 14146 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14147 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14148 if ( _alt==1 ) { 14149 { 14150 { 14151 setState(1754); 14152 _la = _input.LA(1); 14153 if ( !(_la==WS || _la==NEWLINE) ) { 14154 _errHandler.recoverInline(this); 14155 } 14156 consume(); 14157 } 14158 } 14159 } 14160 setState(1759); 14161 _errHandler.sync(this); 14162 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14163 } 14164 setState(1761); 14165 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14166 case 1: 14167 { 14168 setState(1760); description(); 14169 } 14170 break; 14171 } 14172 } 14173 break; 14174 case THROWS_LITERAL: 14175 enterOuterAlt(_localctx, 11); 14176 { 14177 setState(1763); match(THROWS_LITERAL); 14178 setState(1767); 14179 _errHandler.sync(this); 14180 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14181 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14182 if ( _alt==1 ) { 14183 { 14184 { 14185 setState(1764); 14186 _la = _input.LA(1); 14187 if ( !(_la==WS || _la==NEWLINE) ) { 14188 _errHandler.recoverInline(this); 14189 } 14190 consume(); 14191 } 14192 } 14193 } 14194 setState(1769); 14195 _errHandler.sync(this); 14196 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14197 } 14198 setState(1771); 14199 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14200 case 1: 14201 { 14202 setState(1770); match(CLASS_NAME); 14203 } 14204 break; 14205 } 14206 setState(1776); 14207 _errHandler.sync(this); 14208 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14209 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14210 if ( _alt==1 ) { 14211 { 14212 { 14213 setState(1773); 14214 _la = _input.LA(1); 14215 if ( !(_la==WS || _la==NEWLINE) ) { 14216 _errHandler.recoverInline(this); 14217 } 14218 consume(); 14219 } 14220 } 14221 } 14222 setState(1778); 14223 _errHandler.sync(this); 14224 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14225 } 14226 setState(1780); 14227 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14228 case 1: 14229 { 14230 setState(1779); description(); 14231 } 14232 break; 14233 } 14234 } 14235 break; 14236 case VERSION_LITERAL: 14237 enterOuterAlt(_localctx, 12); 14238 { 14239 setState(1782); match(VERSION_LITERAL); 14240 setState(1786); 14241 _errHandler.sync(this); 14242 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14243 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14244 if ( _alt==1 ) { 14245 { 14246 { 14247 setState(1783); 14248 _la = _input.LA(1); 14249 if ( !(_la==WS || _la==NEWLINE) ) { 14250 _errHandler.recoverInline(this); 14251 } 14252 consume(); 14253 } 14254 } 14255 } 14256 setState(1788); 14257 _errHandler.sync(this); 14258 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14259 } 14260 setState(1790); 14261 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14262 case 1: 14263 { 14264 setState(1789); description(); 14265 } 14266 break; 14267 } 14268 } 14269 break; 14270 case CUSTOM_NAME: 14271 enterOuterAlt(_localctx, 13); 14272 { 14273 setState(1792); match(CUSTOM_NAME); 14274 setState(1796); 14275 _errHandler.sync(this); 14276 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14277 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14278 if ( _alt==1 ) { 14279 { 14280 { 14281 setState(1793); 14282 _la = _input.LA(1); 14283 if ( !(_la==WS || _la==NEWLINE) ) { 14284 _errHandler.recoverInline(this); 14285 } 14286 consume(); 14287 } 14288 } 14289 } 14290 setState(1798); 14291 _errHandler.sync(this); 14292 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14293 } 14294 setState(1800); 14295 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 14296 case 1: 14297 { 14298 setState(1799); description(); 14299 } 14300 break; 14301 } 14302 } 14303 break; 14304 default: 14305 throw new NoViableAltException(this); 14306 } 14307 } 14308 catch (RecognitionException re) { 14309 _localctx.exception = re; 14310 _errHandler.reportError(this, re); 14311 _errHandler.recover(this, re); 14312 } 14313 finally { 14314 exitRule(); 14315 } 14316 return _localctx; 14317 } 14318 14319 public static class JavadocInlineTagContext extends ParserRuleContext { 14320 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 14321 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14322 public TerminalNode NEWLINE(int i) { 14323 return getToken(JavadocParser.NEWLINE, i); 14324 } 14325 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 14326 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14327 public TextContext text(int i) { 14328 return getRuleContext(TextContext.class,i); 14329 } 14330 public DescriptionContext description() { 14331 return getRuleContext(DescriptionContext.class,0); 14332 } 14333 public TerminalNode WS(int i) { 14334 return getToken(JavadocParser.WS, i); 14335 } 14336 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 14337 public List<TextContext> text() { 14338 return getRuleContexts(TextContext.class); 14339 } 14340 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14341 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 14342 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14343 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 14344 public TerminalNode LEADING_ASTERISK(int i) { 14345 return getToken(JavadocParser.LEADING_ASTERISK, i); 14346 } 14347 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 14348 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 14349 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 14350 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 14351 public ReferenceContext reference() { 14352 return getRuleContext(ReferenceContext.class,0); 14353 } 14354 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 14355 super(parent, invokingState); 14356 } 14357 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 14358 @Override 14359 public void enterRule(ParseTreeListener listener) { 14360 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 14361 } 14362 @Override 14363 public void exitRule(ParseTreeListener listener) { 14364 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 14365 } 14366 @Override 14367 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14368 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 14369 else return visitor.visitChildren(this); 14370 } 14371 } 14372 14373 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 14374 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 14375 enterRule(_localctx, 144, RULE_javadocInlineTag); 14376 int _la; 14377 try { 14378 int _alt; 14379 enterOuterAlt(_localctx, 1); 14380 { 14381 setState(1804); match(JAVADOC_INLINE_TAG_START); 14382 setState(1880); 14383 switch (_input.LA(1)) { 14384 case CODE_LITERAL: 14385 { 14386 setState(1805); match(CODE_LITERAL); 14387 setState(1812); 14388 _errHandler.sync(this); 14389 _la = _input.LA(1); 14390 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14391 { 14392 setState(1810); 14393 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 14394 case 1: 14395 { 14396 setState(1806); match(WS); 14397 } 14398 break; 14399 14400 case 2: 14401 { 14402 setState(1807); match(NEWLINE); 14403 } 14404 break; 14405 14406 case 3: 14407 { 14408 setState(1808); match(LEADING_ASTERISK); 14409 } 14410 break; 14411 14412 case 4: 14413 { 14414 setState(1809); text(); 14415 } 14416 break; 14417 } 14418 } 14419 setState(1814); 14420 _errHandler.sync(this); 14421 _la = _input.LA(1); 14422 } 14423 } 14424 break; 14425 case DOC_ROOT_LITERAL: 14426 { 14427 setState(1815); match(DOC_ROOT_LITERAL); 14428 setState(1819); 14429 _errHandler.sync(this); 14430 _la = _input.LA(1); 14431 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14432 { 14433 { 14434 setState(1816); 14435 _la = _input.LA(1); 14436 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14437 _errHandler.recoverInline(this); 14438 } 14439 consume(); 14440 } 14441 } 14442 setState(1821); 14443 _errHandler.sync(this); 14444 _la = _input.LA(1); 14445 } 14446 } 14447 break; 14448 case INHERIT_DOC_LITERAL: 14449 { 14450 setState(1822); match(INHERIT_DOC_LITERAL); 14451 setState(1826); 14452 _errHandler.sync(this); 14453 _la = _input.LA(1); 14454 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14455 { 14456 { 14457 setState(1823); 14458 _la = _input.LA(1); 14459 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14460 _errHandler.recoverInline(this); 14461 } 14462 consume(); 14463 } 14464 } 14465 setState(1828); 14466 _errHandler.sync(this); 14467 _la = _input.LA(1); 14468 } 14469 } 14470 break; 14471 case LINK_LITERAL: 14472 { 14473 setState(1829); match(LINK_LITERAL); 14474 setState(1833); 14475 _errHandler.sync(this); 14476 _la = _input.LA(1); 14477 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14478 { 14479 { 14480 setState(1830); 14481 _la = _input.LA(1); 14482 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14483 _errHandler.recoverInline(this); 14484 } 14485 consume(); 14486 } 14487 } 14488 setState(1835); 14489 _errHandler.sync(this); 14490 _la = _input.LA(1); 14491 } 14492 setState(1836); reference(); 14493 setState(1838); 14494 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 14495 case 1: 14496 { 14497 setState(1837); description(); 14498 } 14499 break; 14500 } 14501 } 14502 break; 14503 case LINKPLAIN_LITERAL: 14504 { 14505 setState(1840); match(LINKPLAIN_LITERAL); 14506 setState(1844); 14507 _errHandler.sync(this); 14508 _la = _input.LA(1); 14509 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14510 { 14511 { 14512 setState(1841); 14513 _la = _input.LA(1); 14514 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14515 _errHandler.recoverInline(this); 14516 } 14517 consume(); 14518 } 14519 } 14520 setState(1846); 14521 _errHandler.sync(this); 14522 _la = _input.LA(1); 14523 } 14524 setState(1847); reference(); 14525 setState(1849); 14526 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 14527 case 1: 14528 { 14529 setState(1848); description(); 14530 } 14531 break; 14532 } 14533 } 14534 break; 14535 case LITERAL_LITERAL: 14536 { 14537 setState(1851); match(LITERAL_LITERAL); 14538 setState(1858); 14539 _errHandler.sync(this); 14540 _la = _input.LA(1); 14541 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14542 { 14543 setState(1856); 14544 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 14545 case 1: 14546 { 14547 setState(1852); match(WS); 14548 } 14549 break; 14550 14551 case 2: 14552 { 14553 setState(1853); match(NEWLINE); 14554 } 14555 break; 14556 14557 case 3: 14558 { 14559 setState(1854); match(LEADING_ASTERISK); 14560 } 14561 break; 14562 14563 case 4: 14564 { 14565 setState(1855); text(); 14566 } 14567 break; 14568 } 14569 } 14570 setState(1860); 14571 _errHandler.sync(this); 14572 _la = _input.LA(1); 14573 } 14574 } 14575 break; 14576 case VALUE_LITERAL: 14577 { 14578 setState(1861); match(VALUE_LITERAL); 14579 setState(1865); 14580 _errHandler.sync(this); 14581 _la = _input.LA(1); 14582 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14583 { 14584 { 14585 setState(1862); 14586 _la = _input.LA(1); 14587 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14588 _errHandler.recoverInline(this); 14589 } 14590 consume(); 14591 } 14592 } 14593 setState(1867); 14594 _errHandler.sync(this); 14595 _la = _input.LA(1); 14596 } 14597 setState(1869); 14598 _la = _input.LA(1); 14599 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 14600 { 14601 setState(1868); reference(); 14602 } 14603 } 14604 14605 } 14606 break; 14607 case CUSTOM_NAME: 14608 { 14609 setState(1871); match(CUSTOM_NAME); 14610 setState(1873); 14611 _errHandler.sync(this); 14612 _alt = 1; 14613 do { 14614 switch (_alt) { 14615 case 1: 14616 { 14617 { 14618 setState(1872); 14619 _la = _input.LA(1); 14620 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14621 _errHandler.recoverInline(this); 14622 } 14623 consume(); 14624 } 14625 } 14626 break; 14627 default: 14628 throw new NoViableAltException(this); 14629 } 14630 setState(1875); 14631 _errHandler.sync(this); 14632 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 14633 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14634 setState(1878); 14635 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 14636 case 1: 14637 { 14638 setState(1877); description(); 14639 } 14640 break; 14641 } 14642 } 14643 break; 14644 default: 14645 throw new NoViableAltException(this); 14646 } 14647 setState(1882); match(JAVADOC_INLINE_TAG_END); 14648 } 14649 } 14650 catch (RecognitionException re) { 14651 _localctx.exception = re; 14652 _errHandler.reportError(this, re); 14653 _errHandler.recover(this, re); 14654 } 14655 finally { 14656 exitRule(); 14657 } 14658 return _localctx; 14659 } 14660 14661 public static class HtmlCommentContext extends ParserRuleContext { 14662 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14663 public List<TextContext> text() { 14664 return getRuleContexts(TextContext.class); 14665 } 14666 public TerminalNode NEWLINE(int i) { 14667 return getToken(JavadocParser.NEWLINE, i); 14668 } 14669 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14670 public TextContext text(int i) { 14671 return getRuleContext(TextContext.class,i); 14672 } 14673 public TerminalNode LEADING_ASTERISK(int i) { 14674 return getToken(JavadocParser.LEADING_ASTERISK, i); 14675 } 14676 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 14677 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 14678 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 14679 super(parent, invokingState); 14680 } 14681 @Override public int getRuleIndex() { return RULE_htmlComment; } 14682 @Override 14683 public void enterRule(ParseTreeListener listener) { 14684 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 14685 } 14686 @Override 14687 public void exitRule(ParseTreeListener listener) { 14688 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 14689 } 14690 @Override 14691 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14692 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 14693 else return visitor.visitChildren(this); 14694 } 14695 } 14696 14697 public final HtmlCommentContext htmlComment() throws RecognitionException { 14698 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 14699 enterRule(_localctx, 146, RULE_htmlComment); 14700 int _la; 14701 try { 14702 enterOuterAlt(_localctx, 1); 14703 { 14704 setState(1884); match(HTML_COMMENT_START); 14705 setState(1890); 14706 _errHandler.sync(this); 14707 _la = _input.LA(1); 14708 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14709 { 14710 setState(1888); 14711 switch (_input.LA(1)) { 14712 case WS: 14713 case CHAR: 14714 { 14715 setState(1885); text(); 14716 } 14717 break; 14718 case NEWLINE: 14719 { 14720 setState(1886); match(NEWLINE); 14721 } 14722 break; 14723 case LEADING_ASTERISK: 14724 { 14725 setState(1887); match(LEADING_ASTERISK); 14726 } 14727 break; 14728 default: 14729 throw new NoViableAltException(this); 14730 } 14731 } 14732 setState(1892); 14733 _errHandler.sync(this); 14734 _la = _input.LA(1); 14735 } 14736 setState(1893); match(HTML_COMMENT_END); 14737 } 14738 } 14739 catch (RecognitionException re) { 14740 _localctx.exception = re; 14741 _errHandler.reportError(this, re); 14742 _errHandler.recover(this, re); 14743 } 14744 finally { 14745 exitRule(); 14746 } 14747 return _localctx; 14748 } 14749 14750 public static class TextContext extends ParserRuleContext { 14751 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14752 public TerminalNode WS(int i) { 14753 return getToken(JavadocParser.WS, i); 14754 } 14755 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 14756 public TerminalNode CHAR(int i) { 14757 return getToken(JavadocParser.CHAR, i); 14758 } 14759 public TextContext(ParserRuleContext parent, int invokingState) { 14760 super(parent, invokingState); 14761 } 14762 @Override public int getRuleIndex() { return RULE_text; } 14763 @Override 14764 public void enterRule(ParseTreeListener listener) { 14765 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 14766 } 14767 @Override 14768 public void exitRule(ParseTreeListener listener) { 14769 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 14770 } 14771 @Override 14772 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14773 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 14774 else return visitor.visitChildren(this); 14775 } 14776 } 14777 14778 public final TextContext text() throws RecognitionException { 14779 TextContext _localctx = new TextContext(_ctx, getState()); 14780 enterRule(_localctx, 148, RULE_text); 14781 int _la; 14782 try { 14783 int _alt; 14784 enterOuterAlt(_localctx, 1); 14785 { 14786 setState(1896); 14787 _errHandler.sync(this); 14788 _alt = 1; 14789 do { 14790 switch (_alt) { 14791 case 1: 14792 { 14793 { 14794 setState(1895); 14795 _la = _input.LA(1); 14796 if ( !(_la==WS || _la==CHAR) ) { 14797 _errHandler.recoverInline(this); 14798 } 14799 consume(); 14800 } 14801 } 14802 break; 14803 default: 14804 throw new NoViableAltException(this); 14805 } 14806 setState(1898); 14807 _errHandler.sync(this); 14808 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 14809 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14810 } 14811 } 14812 catch (RecognitionException re) { 14813 _localctx.exception = re; 14814 _errHandler.reportError(this, re); 14815 _errHandler.recover(this, re); 14816 } 14817 finally { 14818 exitRule(); 14819 } 14820 return _localctx; 14821 } 14822 14823 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 14824 switch (ruleIndex) { 14825 case 0: return javadoc_sempred((JavadocContext)_localctx, predIndex); 14826 14827 case 5: return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 14828 14829 case 8: return paragraph_sempred((ParagraphContext)_localctx, predIndex); 14830 14831 case 11: return li_sempred((LiContext)_localctx, predIndex); 14832 14833 case 14: return tr_sempred((TrContext)_localctx, predIndex); 14834 14835 case 17: return td_sempred((TdContext)_localctx, predIndex); 14836 14837 case 20: return th_sempred((ThContext)_localctx, predIndex); 14838 14839 case 23: return body_sempred((BodyContext)_localctx, predIndex); 14840 14841 case 26: return colgroup_sempred((ColgroupContext)_localctx, predIndex); 14842 14843 case 29: return dd_sempred((DdContext)_localctx, predIndex); 14844 14845 case 32: return dt_sempred((DtContext)_localctx, predIndex); 14846 14847 case 35: return head_sempred((HeadContext)_localctx, predIndex); 14848 14849 case 38: return html_sempred((HtmlContext)_localctx, predIndex); 14850 14851 case 41: return option_sempred((OptionContext)_localctx, predIndex); 14852 14853 case 44: return tbody_sempred((TbodyContext)_localctx, predIndex); 14854 14855 case 47: return tfoot_sempred((TfootContext)_localctx, predIndex); 14856 14857 case 50: return thead_sempred((TheadContext)_localctx, predIndex); 14858 14859 case 68: return description_sempred((DescriptionContext)_localctx, predIndex); 14860 } 14861 return true; 14862 } 14863 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 14864 switch (predIndex) { 14865 case 17: return !isNextJavadocTag(); 14866 } 14867 return true; 14868 } 14869 private boolean dt_sempred(DtContext _localctx, int predIndex) { 14870 switch (predIndex) { 14871 case 11: return !isNextJavadocTag(); 14872 } 14873 return true; 14874 } 14875 private boolean body_sempred(BodyContext _localctx, int predIndex) { 14876 switch (predIndex) { 14877 case 8: return !isNextJavadocTag(); 14878 } 14879 return true; 14880 } 14881 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 14882 switch (predIndex) { 14883 case 3: return !isNextJavadocTag(); 14884 } 14885 return true; 14886 } 14887 private boolean tr_sempred(TrContext _localctx, int predIndex) { 14888 switch (predIndex) { 14889 case 5: return !isNextJavadocTag(); 14890 } 14891 return true; 14892 } 14893 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 14894 switch (predIndex) { 14895 case 9: return !isNextJavadocTag(); 14896 } 14897 return true; 14898 } 14899 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 14900 switch (predIndex) { 14901 case 0: return !isNextJavadocTag(); 14902 } 14903 return true; 14904 } 14905 private boolean td_sempred(TdContext _localctx, int predIndex) { 14906 switch (predIndex) { 14907 case 6: return !isNextJavadocTag(); 14908 } 14909 return true; 14910 } 14911 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 14912 switch (predIndex) { 14913 case 1: return !isNextJavadocTag(); 14914 14915 case 2: return !isNextJavadocTag(); 14916 } 14917 return true; 14918 } 14919 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 14920 switch (predIndex) { 14921 case 16: return !isNextJavadocTag(); 14922 } 14923 return true; 14924 } 14925 private boolean th_sempred(ThContext _localctx, int predIndex) { 14926 switch (predIndex) { 14927 case 7: return !isNextJavadocTag(); 14928 } 14929 return true; 14930 } 14931 private boolean li_sempred(LiContext _localctx, int predIndex) { 14932 switch (predIndex) { 14933 case 4: return !isNextJavadocTag(); 14934 } 14935 return true; 14936 } 14937 private boolean dd_sempred(DdContext _localctx, int predIndex) { 14938 switch (predIndex) { 14939 case 10: return !isNextJavadocTag(); 14940 } 14941 return true; 14942 } 14943 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 14944 switch (predIndex) { 14945 case 15: return !isNextJavadocTag(); 14946 } 14947 return true; 14948 } 14949 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 14950 switch (predIndex) { 14951 case 18: return !isNextJavadocTag(); 14952 } 14953 return true; 14954 } 14955 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 14956 switch (predIndex) { 14957 case 13: return !isNextJavadocTag(); 14958 } 14959 return true; 14960 } 14961 private boolean head_sempred(HeadContext _localctx, int predIndex) { 14962 switch (predIndex) { 14963 case 12: return !isNextJavadocTag(); 14964 } 14965 return true; 14966 } 14967 private boolean option_sempred(OptionContext _localctx, int predIndex) { 14968 switch (predIndex) { 14969 case 14: return !isNextJavadocTag(); 14970 } 14971 return true; 14972 } 14973 14974 public static final String _serializedATN = 14975 "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u076f\4\2\t\2\4"+ 14976 "\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"+ 14977 "\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"+ 14978 "\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"+ 14979 "\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!"+ 14980 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 14981 ",\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"+ 14982 "\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="+ 14983 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 14984 "\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"+ 14985 "\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"+ 14986 "\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"+ 14987 "\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"+ 14988 "\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"+ 14989 "\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"+ 14990 "\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"+ 14991 "\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"+ 14992 "\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"+ 14993 "\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"+ 14994 "\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"+ 14995 "\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"+ 14996 "\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"+ 14997 "\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"+ 14998 "\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"+ 14999 "\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"+ 15000 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15001 "\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"+ 15002 "\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"+ 15003 "\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"+ 15004 "\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"+ 15005 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15006 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15007 "\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"+ 15008 "\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"+ 15009 "\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"+ 15010 "\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"+ 15011 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15012 "\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"+ 15013 "\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"+ 15014 "\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"+ 15015 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15016 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15017 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15018 "\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"+ 15019 "\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"+ 15020 "\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"+ 15021 "\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"+ 15022 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15023 "\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"+ 15024 "\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"+ 15025 "\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"+ 15026 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15027 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15028 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15029 "\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"+ 15030 "\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"+ 15031 "\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"+ 15032 "\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"+ 15033 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15034 "\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"+ 15035 "\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"+ 15036 "\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"+ 15037 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15038 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15039 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15040 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15041 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15042 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15043 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15044 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15045 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15046 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15047 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15048 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15049 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15050 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15051 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15052 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15053 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15054 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15055 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15056 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15057 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15058 "\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"+ 15059 "\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"+ 15060 "\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"+ 15061 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15062 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15063 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15064 "\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"+ 15065 "\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"+ 15066 "\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"+ 15067 "\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"+ 15068 "\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"+ 15069 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15070 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15071 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15072 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15073 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15074 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15075 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15076 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15077 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15078 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15079 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15080 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15081 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15082 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15083 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15084 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15085 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15086 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15087 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15088 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15089 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15090 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15091 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15092 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15093 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15094 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15095 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15096 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15097 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15098 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15099 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15100 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15101 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15102 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15103 "J\u0750\nJ\3J\3J\6J\u0754\nJ\rJ\16J\u0755\3J\5J\u0759\nJ\5J\u075b\nJ\3"+ 15104 "J\3J\3K\3K\3K\3K\7K\u0763\nK\fK\16K\u0766\13K\3K\3K\3L\6L\u076b\nL\rL"+ 15105 "\16L\u076c\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+ 15106 "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+ 15107 "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6\6\b\b"+ 15108 "\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\3\2\30"+ 15109 "\31\4\2\6\6\32\32\u0a86\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7\3\2\2"+ 15110 "\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2\2\2\20"+ 15111 "\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2\2\30\u0191"+ 15112 "\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2 \u0203\3\2"+ 15113 "\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3\2\2\2*\u0260"+ 15114 "\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62\u02d2\3\2\2"+ 15115 "\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324\3\2\2\2<\u032f"+ 15116 "\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D\u03a1\3\2\2\2F"+ 15117 "\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2\2\2N\u03fe\3\2"+ 15118 "\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470\3\2\2\2X\u047d"+ 15119 "\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2`\u04cd\3\2\2\2"+ 15120 "b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3\2\2\2j\u0550\3"+ 15121 "\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584\3\2\2\2t\u0591"+ 15122 "\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|\u05c5\3\2\2\2~"+ 15123 "\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2\u0084\u05f9\3\2"+ 15124 "\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616\3\2\2\2\u008c"+ 15125 "\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092\u070e\3\2"+ 15126 "\2\2\u0094\u075e\3\2\2\2\u0096\u076a\3\2\2\2\u0098\u00a1\5\4\3\2\u0099"+ 15127 "\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c\u00a1"+ 15128 "\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1\5\u0092"+ 15129 "J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2\2\u00a0"+ 15130 "\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2"+ 15131 "\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15132 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15133 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15134 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15135 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15136 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15137 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15138 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15139 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15140 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15141 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15142 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15143 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15144 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15145 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15146 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15147 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15148 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15149 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15150 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15151 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15152 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15153 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15154 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15155 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15156 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15157 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15158 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15159 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15160 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15161 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15162 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15163 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15164 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15165 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15166 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15167 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15168 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15169 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15170 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15171 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15172 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15173 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15174 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15175 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15176 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15177 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15178 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15179 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15180 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15181 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15182 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15183 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15184 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15185 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 15186 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 15187 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 15188 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 15189 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 15190 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 15191 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 15192 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 15193 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 15194 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 15195 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 15196 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 15197 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 15198 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 15199 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 15200 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 15201 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 15202 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 15203 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 15204 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 15205 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 15206 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 15207 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 15208 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 15209 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 15210 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 15211 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 15212 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 15213 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 15214 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 15215 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 15216 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 15217 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 15218 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 15219 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 15220 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 15221 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 15222 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 15223 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 15224 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 15225 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 15226 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 15227 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 15228 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 15229 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 15230 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 15231 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 15232 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 15233 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 15234 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 15235 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 15236 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 15237 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 15238 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 15239 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 15240 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 15241 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 15242 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 15243 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 15244 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 15245 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 15246 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 15247 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 15248 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 15249 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 15250 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 15251 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 15252 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 15253 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 15254 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 15255 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 15256 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 15257 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 15258 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 15259 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 15260 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 15261 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 15262 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 15263 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 15264 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 15265 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 15266 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 15267 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 15268 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 15269 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 15270 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 15271 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 15272 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 15273 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 15274 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 15275 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 15276 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 15277 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 15278 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 15279 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 15280 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 15281 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 15282 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 15283 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 15284 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 15285 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 15286 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 15287 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 15288 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 15289 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 15290 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 15291 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 15292 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 15293 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 15294 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 15295 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 15296 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 15297 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 15298 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 15299 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 15300 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 15301 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 15302 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 15303 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 15304 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 15305 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 15306 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 15307 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 15308 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 15309 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 15310 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 15311 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 15312 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 15313 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 15314 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 15315 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 15316 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 15317 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 15318 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 15319 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 15320 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 15321 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 15322 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 15323 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 15324 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 15325 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 15326 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 15327 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 15328 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 15329 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 15330 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 15331 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 15332 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 15333 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 15334 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 15335 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 15336 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 15337 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 15338 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 15339 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 15340 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 15341 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 15342 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 15343 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 15344 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 15345 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 15346 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 15347 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 15348 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 15349 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 15350 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 15351 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 15352 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 15353 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 15354 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 15355 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 15356 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 15357 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 15358 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 15359 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 15360 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 15361 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 15362 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 15363 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 15364 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 15365 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 15366 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 15367 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 15368 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 15369 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 15370 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 15371 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 15372 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 15373 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 15374 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 15375 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 15376 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 15377 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 15378 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 15379 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 15380 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 15381 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 15382 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 15383 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 15384 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 15385 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 15386 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 15387 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 15388 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 15389 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 15390 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 15391 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 15392 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 15393 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 15394 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 15395 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 15396 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 15397 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 15398 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 15399 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 15400 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 15401 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 15402 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 15403 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 15404 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 15405 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 15406 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 15407 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 15408 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 15409 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 15410 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 15411 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 15412 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 15413 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 15414 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 15415 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 15416 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 15417 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 15418 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 15419 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 15420 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 15421 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 15422 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 15423 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 15424 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 15425 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 15426 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 15427 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 15428 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 15429 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 15430 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 15431 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 15432 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 15433 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 15434 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 15435 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 15436 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 15437 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 15438 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 15439 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 15440 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 15441 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 15442 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 15443 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 15444 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 15445 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 15446 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 15447 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 15448 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 15449 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 15450 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 15451 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 15452 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 15453 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 15454 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 15455 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 15456 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 15457 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 15458 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 15459 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 15460 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 15461 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 15462 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 15463 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 15464 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 15465 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 15466 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 15467 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 15468 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 15469 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 15470 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 15471 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 15472 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 15473 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 15474 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 15475 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 15476 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 15477 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 15478 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 15479 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 15480 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 15481 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 15482 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 15483 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 15484 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 15485 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 15486 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 15487 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 15488 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 15489 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 15490 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 15491 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 15492 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 15493 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 15494 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 15495 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 15496 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 15497 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 15498 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 15499 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 15500 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 15501 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 15502 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 15503 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 15504 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 15505 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 15506 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 15507 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 15508 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 15509 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 15510 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 15511 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 15512 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 15513 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 15514 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 15515 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 15516 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 15517 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 15518 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 15519 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 15520 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 15521 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 15522 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 15523 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 15524 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 15525 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 15526 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 15527 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 15528 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 15529 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 15530 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 15531 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 15532 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 15533 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 15534 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 15535 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 15536 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 15537 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 15538 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 15539 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 15540 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 15541 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 15542 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 15543 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 15544 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 15545 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 15546 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 15547 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 15548 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 15549 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 15550 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 15551 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 15552 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 15553 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 15554 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 15555 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 15556 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 15557 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 15558 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 15559 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 15560 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 15561 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 15562 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 15563 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 15564 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 15565 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 15566 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 15567 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 15568 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 15569 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 15570 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 15571 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 15572 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 15573 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 15574 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 15575 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 15576 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 15577 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 15578 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 15579 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 15580 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 15581 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 15582 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 15583 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 15584 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 15585 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 15586 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 15587 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 15588 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 15589 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 15590 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 15591 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 15592 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 15593 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 15594 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 15595 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 15596 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 15597 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 15598 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 15599 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 15600 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 15601 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 15602 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 15603 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 15604 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 15605 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 15606 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 15607 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 15608 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 15609 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 15610 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 15611 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 15612 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 15613 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 15614 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 15615 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 15616 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 15617 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 15618 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 15619 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 15620 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 15621 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 15622 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 15623 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 15624 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 15625 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 15626 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 15627 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 15628 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 15629 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 15630 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 15631 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 15632 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 15633 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 15634 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 15635 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 15636 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 15637 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 15638 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 15639 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 15640 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 15641 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 15642 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 15643 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 15644 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 15645 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 15646 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 15647 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 15648 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 15649 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 15650 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 15651 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 15652 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 15653 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 15654 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 15655 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 15656 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 15657 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 15658 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 15659 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 15660 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 15661 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 15662 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 15663 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 15664 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 15665 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 15666 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 15667 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 15668 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 15669 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 15670 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 15671 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 15672 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 15673 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 15674 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 15675 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 15676 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 15677 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 15678 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 15679 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 15680 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 15681 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 15682 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 15683 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 15684 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 15685 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 15686 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 15687 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 15688 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 15689 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 15690 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 15691 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 15692 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 15693 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 15694 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 15695 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 15696 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 15697 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 15698 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 15699 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 15700 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 15701 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 15702 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 15703 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 15704 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 15705 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 15706 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 15707 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 15708 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 15709 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 15710 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 15711 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 15712 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 15713 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 15714 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 15715 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 15716 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 15717 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 15718 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 15719 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 15720 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 15721 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 15722 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 15723 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 15724 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 15725 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 15726 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 15727 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 15728 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 15729 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 15730 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 15731 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 15732 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 15733 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 15734 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 15735 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 15736 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 15737 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 15738 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 15739 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 15740 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 15741 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 15742 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 15743 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 15744 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 15745 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 15746 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 15747 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 15748 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 15749 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 15750 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 15751 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 15752 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 15753 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 15754 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 15755 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 15756 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 15757 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 15758 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 15759 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 15760 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 15761 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 15762 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 15763 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 15764 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 15765 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 15766 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 15767 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 15768 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 15769 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 15770 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 15771 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 15772 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 15773 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 15774 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 15775 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 15776 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 15777 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 15778 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 15779 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 15780 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 15781 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 15782 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 15783 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 15784 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 15785 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 15786 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 15787 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 15788 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 15789 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 15790 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 15791 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 15792 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 15793 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 15794 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 15795 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 15796 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 15797 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 15798 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 15799 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 15800 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 15801 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 15802 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 15803 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 15804 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 15805 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 15806 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 15807 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 15808 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 15809 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 15810 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 15811 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 15812 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 15813 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 15814 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 15815 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 15816 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 15817 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 15818 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 15819 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 15820 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 15821 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 15822 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 15823 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 15824 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 15825 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 15826 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 15827 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 15828 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 15829 "\u0091\3\2\2\2\u070e\u075a\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 15830 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 15831 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 15832 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 15833 "\u075b\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 15834 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 15835 "\u071e\3\2\2\2\u071e\u075b\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 15836 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 15837 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075b\3\2\2\2\u0726\u0724\3\2"+ 15838 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 15839 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 15840 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 15841 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075b\3\2\2\2\u0732\u0736"+ 15842 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 15843 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 15844 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 15845 "\2\2\u073b\u073c\3\2\2\2\u073c\u075b\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 15846 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 15847 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 15848 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 15849 "\2\2\u0745\u075b\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 15850 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 15851 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 15852 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075b"+ 15853 "\3\2\2\2\u0751\u0753\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 15854 "\u0754\u0755\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758"+ 15855 "\3\2\2\2\u0757\u0759\5\u008aF\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2"+ 15856 "\2\u0759\u075b\3\2\2\2\u075a\u070f\3\2\2\2\u075a\u0719\3\2\2\2\u075a\u0720"+ 15857 "\3\2\2\2\u075a\u0727\3\2\2\2\u075a\u0732\3\2\2\2\u075a\u073d\3\2\2\2\u075a"+ 15858 "\u0747\3\2\2\2\u075a\u0751\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u075d\7\26"+ 15859 "\2\2\u075d\u0093\3\2\2\2\u075e\u0764\7\4\2\2\u075f\u0763\5\u0096L\2\u0760"+ 15860 "\u0763\7\b\2\2\u0761\u0763\7\3\2\2\u0762\u075f\3\2\2\2\u0762\u0760\3\2"+ 15861 "\2\2\u0762\u0761\3\2\2\2\u0763\u0766\3\2\2\2\u0764\u0762\3\2\2\2\u0764"+ 15862 "\u0765\3\2\2\2\u0765\u0767\3\2\2\2\u0766\u0764\3\2\2\2\u0767\u0768\7]"+ 15863 "\2\2\u0768\u0095\3\2\2\2\u0769\u076b\t\n\2\2\u076a\u0769\3\2\2\2\u076b"+ 15864 "\u076c\3\2\2\2\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u0097\3\2"+ 15865 "\2\2\u00c5\u00a0\u00a2\u00a6\u00ab\u00b1\u00e5\u00ed\u00ef\u00fa\u0103"+ 15866 "\u010a\u0110\u011b\u011d\u012b\u012d\u0132\u013a\u013c\u0147\u0172\u0174"+ 15867 "\u017f\u0181\u018c\u01b7\u01b9\u01c4\u01c6\u01d1\u01fc\u01fe\u0209\u020b"+ 15868 "\u0216\u0241\u0243\u024e\u0250\u025b\u0286\u0288\u0293\u0295\u02a0\u02cb"+ 15869 "\u02cd\u02d8\u02da\u02e5\u0310\u0312\u031d\u031f\u032a\u0355\u0357\u0362"+ 15870 "\u0364\u036f\u039a\u039c\u03a7\u03a9\u03b4\u03df\u03e1\u03ec\u03ee\u03f9"+ 15871 "\u0424\u0426\u0431\u0433\u043e\u0469\u046b\u0476\u0478\u0483\u04ae\u04b0"+ 15872 "\u04bb\u04bd\u04c8\u04f3\u04f5\u0500\u0502\u050d\u0538\u053a\u054e\u0556"+ 15873 "\u0558\u0563\u0565\u0570\u0572\u057d\u057f\u058a\u058c\u0597\u0599\u05a4"+ 15874 "\u05a6\u05b1\u05b3\u05be\u05c0\u05cb\u05cd\u05d8\u05da\u05e5\u05e7\u05f2"+ 15875 "\u05f4\u05ff\u0601\u0616\u0618\u061e\u0622\u0625\u0628\u062d\u0630\u0633"+ 15876 "\u0636\u0639\u063d\u063f\u0645\u064e\u0652\u0658\u065c\u0662\u0666\u066b"+ 15877 "\u066f\u0675\u0679\u067e\u0682\u0688\u068c\u0692\u0696\u069a\u069c\u06a2"+ 15878 "\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9"+ 15879 "\u06df\u06e3\u06e9\u06ed\u06f2\u06f6\u06fc\u0700\u0706\u070a\u070c\u0714"+ 15880 "\u0716\u071d\u0724\u072b\u0730\u0736\u073b\u0742\u0744\u074b\u074f\u0755"+ 15881 "\u0758\u075a\u0762\u0764\u076c"; 15882 public static final ATN _ATN = 15883 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 15884 static { 15885 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 15886 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 15887 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 15888 } 15889 } 15890}